C# est devenu une option populaire et adaptable pour les développeurs parmi les nombreux langages de programmation disponibles. Le concept de collections est au cœur de la vaste bibliothèque et des frameworks de C#, qui sont l'un des principaux avantages du langage. En C#, une collection est essentielle pour stocker et organiser efficacement les données. Elles offrent aux développeurs une large gamme d'outils efficaces pour résoudre des problèmes de programmation complexes. Nous approfondirons les collections dans cet article, en couvrant leurs caractéristiques, types et stratégies d'utilisation optimales.

Comment utiliser les collections C#

1. Créez un nouveau projet d'application console.
2. Créez un objet pour la collection en C#.
3. Ajoutez les valeurs à la classe de collection, qui peut stocker plusieurs ensembles d'objets.
4. Traitez les opérations sur les valeurs telles que l'ajout, la suppression, le tri, etc.
5. Affichez le résultat et disposez de l'objet.

C# : Comprendre les collections

Les collections en C# sont des conteneurs qui permettent aux programmeurs de travailler avec et de stocker des ensembles de classes d'objets. Ces objets sont flexibles et adaptables à de nombreux environnements de programmation, et peuvent être du même type ou de types distincts. La plupart des classes de collection implémentent des composants de l'espace de noms System en C#, ce qui signifie l'importation d'espaces de noms tels que System.Collections et System.Collections.Generic, qui offrent diverses classes de collection génériques et non génériques. Les collections permettent également l'allocation dynamique de mémoire, l'ajout, la recherche et le tri d'éléments au sein des classes de collection.

Types de collections non génériques

ArrayList, Hashtable et Queue sont quelques-unes des classes de collection non génériques disponibles en C# qui ont été incluses dans les premières versions du langage. Ces collections offrent une alternative à la définition explicite des types d'éléments que vous souhaitez conserver et manipuler. Cependant, les développeurs choisissent fréquemment des collections génériques en raison de leur performance supérieure et de leur sécurité de type.

Collections génériques

Les itérations ultérieures de C# ont inclus des collections génériques pour surmonter les inconvénients des collections non génériques. Elles offrent une sécurité de type lors de la compilation et permettent aux développeurs de traiter des données étroitement typées. Les classes de collection génériques List, Dictionary<TKey, TValue>, Queue et Stack sont quelques-unes des plus couramment utilisées. Ces collections sont l'option privilégiée dans le développement C# contemporain car elles offrent de meilleures performances et une vérification de type à la compilation.

Principaux types de collections C#

1. List

Un tableau dynamique qui facilite l'insertion et la suppression rapide et facile d'éléments est la classe List<t>. C'est une option flexible pour les situations nécessitant une collection redimensionnable puisqu'elle offre des moyens de filtrer, rechercher et manipuler des composants.

// Creating a list with integers and adding/removing elements
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.Add(6); // Adds element '6' to the end
numbers.Remove(3); // Removes the first occurrence of the element '3'

// Creating a list with integers and adding/removing elements
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.Add(6); // Adds element '6' to the end
numbers.Remove(3); // Removes the first occurrence of the element '3'

' Creating a list with integers and adding/removing elements
Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
numbers.Add(6) ' Adds element '6' to the end
numbers.Remove(3) ' Removes the first occurrence of the element '3'

' Creating a list with integers and adding/removing elements
Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
numbers.Add(6) ' Adds element '6' to the end
numbers.Remove(3) ' Removes the first occurrence of the element '3'

2. Dictionary<TKey, TValue>

Avec des vitesses de recherche rapides, une collection de paires clé-valeur est représentée par la classe Dictionary<TKey, TValue>. Elle est fréquemment employée dans des situations où un accès rapide aux données par le biais d'une valeur clé unique est crucial. Cette clé est utilisée pour accéder aux éléments dans le dictionnaire.

// Creating a dictionary mapping names to ages
Dictionary<string, int> ageMap = new Dictionary<string, int>();
ageMap.Add("John", 25); // The string "John" is the key that can access the value 25
ageMap["Jane"] = 30; // Setting the key "Jane" to hold the value 30

// Creating a dictionary mapping names to ages
Dictionary<string, int> ageMap = new Dictionary<string, int>();
ageMap.Add("John", 25); // The string "John" is the key that can access the value 25
ageMap["Jane"] = 30; // Setting the key "Jane" to hold the value 30

' Creating a dictionary mapping names to ages
Dim ageMap As New Dictionary(Of String, Integer)()
ageMap.Add("John", 25) ' The string "John" is the key that can access the value 25
ageMap("Jane") = 30 ' Setting the key "Jane" to hold the value 30

' Creating a dictionary mapping names to ages
Dim ageMap As New Dictionary(Of String, Integer)()
ageMap.Add("John", 25) ' The string "John" is the key that can access the value 25
ageMap("Jane") = 30 ' Setting the key "Jane" to hold the value 30

3. Queue et Stack

La collection premier arrivé, premier sorti (FIFO), et les paradigmes dernier arrivé, premier sorti (LIFO) sont implémentés, respectivement, par les classes génériques Queue<t> et Stack<t>. Ils peuvent être utilisés pour gérer les éléments dans un certain ordre en fonction des besoins de l'application.

// Creating and manipulating a queue
Queue<string> tasks = new Queue<string>(); 
tasks.Enqueue("Task 1"); // Adding to the queue
tasks.Enqueue("Task 2");

// Creating and manipulating a stack
Stack<double> numbers = new Stack<double>();
numbers.Push(3.14); // Adding to the stack
numbers.Push(2.71);

// Creating and manipulating a queue
Queue<string> tasks = new Queue<string>(); 
tasks.Enqueue("Task 1"); // Adding to the queue
tasks.Enqueue("Task 2");

// Creating and manipulating a stack
Stack<double> numbers = new Stack<double>();
numbers.Push(3.14); // Adding to the stack
numbers.Push(2.71);

' Creating and manipulating a queue
Dim tasks As New Queue(Of String)()
tasks.Enqueue("Task 1") ' Adding to the queue
tasks.Enqueue("Task 2")

' Creating and manipulating a stack
Dim numbers As New Stack(Of Double)()
numbers.Push(3.14) ' Adding to the stack
numbers.Push(2.71)

' Creating and manipulating a queue
Dim tasks As New Queue(Of String)()
tasks.Enqueue("Task 1") ' Adding to the queue
tasks.Enqueue("Task 2")

' Creating and manipulating a stack
Dim numbers As New Stack(Of Double)()
numbers.Push(3.14) ' Adding to the stack
numbers.Push(2.71)

4. HashSet

Les éléments uniques disposés dans une collection non ordonnée sont représentés par la classe HashSet<t>. Elle offre des moyens efficaces pour effectuer des opérations sur des ensembles telles que la différence, l'union et l'intersection.

// Creating hashsets and performing a union operation
HashSet<int> setA = new HashSet<int> { 1, 2, 3, 4 };
HashSet<int> setB = new HashSet<int> { 3, 4, 5, 6 };
HashSet<int> unionSet = new HashSet<int>(setA);
unionSet.UnionWith(setB); // Combining setA and setB

// Creating hashsets and performing a union operation
HashSet<int> setA = new HashSet<int> { 1, 2, 3, 4 };
HashSet<int> setB = new HashSet<int> { 3, 4, 5, 6 };
HashSet<int> unionSet = new HashSet<int>(setA);
unionSet.UnionWith(setB); // Combining setA and setB

' Creating hashsets and performing a union operation
Dim setA As New HashSet(Of Integer) From {1, 2, 3, 4}
Dim setB As New HashSet(Of Integer) From {3, 4, 5, 6}
Dim unionSet As New HashSet(Of Integer)(setA)
unionSet.UnionWith(setB) ' Combining setA and setB

' Creating hashsets and performing a union operation
Dim setA As New HashSet(Of Integer) From {1, 2, 3, 4}
Dim setB As New HashSet(Of Integer) From {3, 4, 5, 6}
Dim unionSet As New HashSet(Of Integer)(setA)
unionSet.UnionWith(setB) ' Combining setA and setB

IronPDF

Une bibliothèque C# appelée IronPDF facilite la création, l'édition et l'affichage de documents PDF dans les applications .NET. Elle offre de nombreuses options de licence, une compatibilité multiplateforme, un rendu de haute qualité et une conversion de HTML en PDF. L'API conviviale d'IronPDF simplifie la gestion des PDFs, en en faisant un outil précieux pour les développeurs C#.

La fonction phare d'IronPDF est sa capacité de conversion HTML en PDF, qui préserve toutes les dispositions et styles. Elle génère des PDFs à partir de contenu web, la rendant parfaite pour les rapports, factures et documentation. Les fichiers HTML, les URLs et les chaînes HTML peuvent être convertis en PDFs sans effort.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Les fonctionnalités clés d'IronPDF incluent :

• Convertir HTML en PDF : Avec IronPDF, les programmeurs peuvent créer des documents PDF à partir de texte HTML, y compris CSS et JavaScript. Cela est particulièrement utile pour ceux qui sont déjà familiers avec les outils de développement web et souhaitent utiliser HTML et CSS pour créer des PDFs.
• Génération et manipulation de PDF : La bibliothèque fournit la possibilité de créer des documents PDF à partir de zéro de manière programmatique. En outre, elle facilite l'édition de PDFs préexistants, permettant des opérations telles que l'extraction de texte, l'ajout de filigranes, la division de PDFs, et plus encore.
• Rendu supérieur : IronPDF utilise un moteur de rendu pour générer des sorties PDF de la plus haute qualité, garantissant que les documents finaux conservent clarté et intégrité visuelle.
• Compatibilité multiplateforme : IronPDF est conçu pour fonctionner avec à la fois .NET Core et .NET Framework, lui permettant d'être utilisé dans diverses applications et sur une gamme de plateformes.
• Optimisation des performances : Même en travaillant avec des documents PDF volumineux ou compliqués, la bibliothèque est conçue pour fournir une production et un rendu efficaces des PDFs.

Pour en savoir plus sur la documentation d'IronPDF, consultez la Documentation IronPDF.

Installation d'IronPDF

Installez d'abord la bibliothèque IronPDF en utilisant la console de gestion de package ou le gestionnaire de packages NuGet avec :

Install-Package IronPdf

Utiliser le gestionnaire de packages NuGet pour rechercher le package "IronPDF" est une option supplémentaire. Nous pouvons choisir et télécharger le package nécessaire de cette liste parmi tous les packages NuGet associés à IronPDF.

Création de documents avec des collections avec IronPDF

Comprendre le rôle que jouent les collections dans les structures de données et l'organisation est crucial avant d'entrer dans l'interface avec IronPDF. Les développeurs peuvent stocker, récupérer et modifier des groupes d'objets de manière organisée en utilisant des collections. Avec tant de types différents disponibles, tels que List, Dictionary<TKey, TValue> et HashSet, les développeurs peuvent choisir la collection qui correspond le mieux à leurs besoins.

Imaginez que vous devez créer un rapport avec une liste de transactions de vente. Les données peuvent être efficacement organisées à l'aide d'une List<Transaction>, qui sert de base pour un traitement et un affichage supplémentaires.

// Define the Transaction class
public class Transaction
{
    public string ProductName { get; set; }
    public decimal Amount { get; set; }
    public DateTime Date { get; set; }
}

// Create a list of transactions
List<Transaction> transactions = new List<Transaction>
{
    new Transaction { ProductName = "Product A", Amount = 100.50m, Date = DateTime.Now.AddDays(-2) },
    new Transaction { ProductName = "Product B", Amount = 75.20m, Date = DateTime.Now.AddDays(-1) },
    // Add more transactions as needed
};

// Define the Transaction class
public class Transaction
{
    public string ProductName { get; set; }
    public decimal Amount { get; set; }
    public DateTime Date { get; set; }
}

// Create a list of transactions
List<Transaction> transactions = new List<Transaction>
{
    new Transaction { ProductName = "Product A", Amount = 100.50m, Date = DateTime.Now.AddDays(-2) },
    new Transaction { ProductName = "Product B", Amount = 75.20m, Date = DateTime.Now.AddDays(-1) },
    // Add more transactions as needed
};

' Define the Transaction class
Public Class Transaction
	Public Property ProductName() As String
	Public Property Amount() As Decimal
	Public Property [Date]() As DateTime
End Class

' Create a list of transactions
Private transactions As New List(Of Transaction) From {
	New Transaction With {
		.ProductName = "Product A",
		.Amount = 100.50D,
		.Date = DateTime.Now.AddDays(-2)
	},
	New Transaction With {
		.ProductName = "Product B",
		.Amount = 75.20D,
		.Date = DateTime.Now.AddDays(-1)
	}
}

' Define the Transaction class
Public Class Transaction
	Public Property ProductName() As String
	Public Property Amount() As Decimal
	Public Property [Date]() As DateTime
End Class

' Create a list of transactions
Private transactions As New List(Of Transaction) From {
	New Transaction With {
		.ProductName = "Product A",
		.Amount = 100.50D,
		.Date = DateTime.Now.AddDays(-2)
	},
	New Transaction With {
		.ProductName = "Product B",
		.Amount = 75.20D,
		.Date = DateTime.Now.AddDays(-1)
	}
}

Dans le PDF, nous ferons un tableau simple qui répertorie le nom du produit, le montant de la transaction et la date pour chacun.

using IronPdf;

// Create a PDF document renderer
var pdfDocument = new HtmlToPdf();

// HTML content with a table populated by data from the 'transactions' list
string htmlContent = "<table><tr><th>Product Name</th><th>Amount</th><th>Date</th></tr>";
foreach (var transaction in transactions)
{
    htmlContent += $"<tr><td>{transaction.ProductName}</td><td>{transaction.Amount}</td><td>{transaction.Date.ToShortDateString()}</td></tr>";
}
htmlContent += "</table>";

// Convert HTML to PDF
PdfDocument pdf = pdfDocument.RenderHtmlAsPdf(htmlContent);

// Specify the file path to save the PDF
string pdfFilePath = "transactions_report.pdf";
pdf.SaveAs(pdfFilePath);

using IronPdf;

// Create a PDF document renderer
var pdfDocument = new HtmlToPdf();

// HTML content with a table populated by data from the 'transactions' list
string htmlContent = "<table><tr><th>Product Name</th><th>Amount</th><th>Date</th></tr>";
foreach (var transaction in transactions)
{
    htmlContent += $"<tr><td>{transaction.ProductName}</td><td>{transaction.Amount}</td><td>{transaction.Date.ToShortDateString()}</td></tr>";
}
htmlContent += "</table>";

// Convert HTML to PDF
PdfDocument pdf = pdfDocument.RenderHtmlAsPdf(htmlContent);

// Specify the file path to save the PDF
string pdfFilePath = "transactions_report.pdf";
pdf.SaveAs(pdfFilePath);

Imports IronPdf

' Create a PDF document renderer
Private pdfDocument = New HtmlToPdf()

' HTML content with a table populated by data from the 'transactions' list
Private htmlContent As String = "<table><tr><th>Product Name</th><th>Amount</th><th>Date</th></tr>"
For Each transaction In transactions
	htmlContent &= $"<tr><td>{transaction.ProductName}</td><td>{transaction.Amount}</td><td>{transaction.Date.ToShortDateString()}</td></tr>"
Next transaction
htmlContent &= "</table>"

' Convert HTML to PDF
Dim pdf As PdfDocument = pdfDocument.RenderHtmlAsPdf(htmlContent)

' Specify the file path to save the PDF
Dim pdfFilePath As String = "transactions_report.pdf"
pdf.SaveAs(pdfFilePath)

Imports IronPdf

' Create a PDF document renderer
Private pdfDocument = New HtmlToPdf()

' HTML content with a table populated by data from the 'transactions' list
Private htmlContent As String = "<table><tr><th>Product Name</th><th>Amount</th><th>Date</th></tr>"
For Each transaction In transactions
	htmlContent &= $"<tr><td>{transaction.ProductName}</td><td>{transaction.Amount}</td><td>{transaction.Date.ToShortDateString()}</td></tr>"
Next transaction
htmlContent &= "</table>"

' Convert HTML to PDF
Dim pdf As PdfDocument = pdfDocument.RenderHtmlAsPdf(htmlContent)

' Specify the file path to save the PDF
Dim pdfFilePath As String = "transactions_report.pdf"
pdf.SaveAs(pdfFilePath)

Les développeurs ont la possibilité d'enregistrer le document PDF sur disque ou de le montrer aux utilisateurs une fois qu'il a été produit. IronPDF offre plusieurs options de sortie, y compris le streaming dans un navigateur, l'enregistrement de fichiers et l'intégration au stockage dans le cloud.

L'écran ci-dessus montre la sortie générée à partir du code ci-dessus. Pour en savoir plus sur le code, consultez Exemple d'utilisation de HTML pour créer un PDF.

Conclusion

Une pléthore d'opportunités pour la production dynamique de documents est rendue possible par la combinaison de collections avec IronPDF. Les développeurs peuvent gérer et organiser efficacement les données en utilisant des collections, et IronPDF facilite la création de documents PDF visuellement attrayants. La puissance combinée d'IronPDF et des collections offre une solution fiable et adaptable pour la production de contenu dynamique dans les applications C#, quel que soit le type de document que vous produisez - factures, rapports ou autre.

L'édition $999 Lite d'IronPDF comprend un an de support logiciel, des options de mise à jour et une licence permanente. Les utilisateurs ont également l'occasion d'évaluer le produit dans des circonstances réelles pendant la période d'essai avec filigrane. Pour en savoir plus sur le coût, la licence et l'essai gratuit d'IronPDF, veuillez visiter les Informations sur la licence d'IronPDF. Pour plus d'informations sur Iron Software, rendez-vous sur le Site Web d'Iron Software.