L'interface IEnumerable de C# est l'un des outils les plus polyvalents du framework .NET, permettant aux développeurs de travailler avec des collections de manière très flexible. Lorsqu'il est combiné avec IronPDF, IEnumerable permet une manipulation dynamique des données et une génération efficace de PDF, le rendant idéal pour des scénarios tels que la création de rapports, l'exportation de données ou la génération de documents à partir de requêtes de base de données.
L'utilisation d'IEnumerable garantit que votre application reste évolutive et économe en mémoire, car elle traite les données de manière différée et évite de charger des ensembles de données entiers en mémoire en une seule fois. Cela est particulièrement utile pour les applications à grande échelle gérant de vastes collections de données, telles qu'une table de base de données massive.
IronPDF est une bibliothèque .NET puissante conçue pour simplifier le processus de création, d'édition et de gestion de fichiers PDF par programmation. Elle offre un large éventail de fonctionnalités, y compris la conversion d'HTML en PDF, l'extraction de texte, la fusion de PDF et plus encore. En intégrant IronPDF à vos projets C#, vous pouvez gérer efficacement des tâches PDF complexes sans avoir besoin d'une expertise approfondie des internals PDF.
IronPDF prend également en charge une variété de formats, vous permettant de générer des PDF à partir de HTML brut, de Razor Views, de pages web ASP.NET, ou même directement à partir de structures de données. Cette flexibilité en fait un outil essentiel pour les développeurs construisant des applications modernes et basées sur les données.
Pour utiliser IronPDF dans votre projet, suivez ces étapes :
L'interface IEnumerable représente une séquence d'éléments qui peuvent être énumérés. Les exemples courants incluent les tableaux, les listes et les résultats de requêtes LINQ. Grâce à LINQ, vous pouvez filtrer, trier et projeter des données au format désiré avant de générer des PDF avec IronPDF.
L'un des principaux avantages d'IEnumerable est son modèle d'exécution différée, ce qui permet aux requêtes d'être exécutées uniquement lorsque leurs résultats sont accédés. Cela permet une manipulation efficace des données et réduit la surcharge computationnelle dans des flux de travail complexes.
Étant donné qu'une liste implémente IEnumerable, toute collection, comme List, peut être traitée comme un IEnumerable, permettant des opérations LINQ faciles, le filtrage et la transformation.
Imaginez que vous avez une liste qui implémente IEnumerable d'employés que vous devez exporter sous forme de tableau PDF. En utilisant IEnumerable et IronPDF, vous pouvez parcourir les données et les convertir en un PDF bien structuré.
Pour améliorer la présentation, vous pouvez utiliser des tableaux HTML avec des CSS en ligne pour styliser les rangées et colonnes dynamiquement en fonction des données. Cela garantit que la sortie PDF est à la fois fonctionnelle et esthétiquement attrayante.
Avec LINQ, vous pouvez filtrer et transformer vos données avant de les transmettre à IronPDF. Par exemple, vous pourriez filtrer uniquement les employés actifs et formater leurs noms en majuscules pour la sortie PDF.
var activeEmployees = employees.Where(e => e.IsActive).Select(e => new {
Name = e.Name.ToUpper(),
Position = e.Position,
Age = e.Age
});Dim activeEmployees = employees.Where(Function(e) e.IsActive).Select(Function(e) New With {
Key .Name = e.Name.ToUpper(),
Key .Position = e.Position,
Key .Age = e.Age
})Ces données transformées peuvent ensuite être converties en un format HTML adapté aux PDF pour le rendu.
Si vous avez besoin de générer un PDF séparé pour chaque enregistrement dans une collection, vous pouvez utiliser une boucle foreach pour parcourir l'enumerable et générer des PDF individuels de manière dynamique. Cela est particulièrement utile pour créer des factures, des certificats ou des rapports personnalisés.
foreach (var employee in employees)
{
string html = $"<h1>{employee.Name}</h1><p>Position: {employee.Position}</p><p>Age: {employee.Age}</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs($"{employee.Name}_Report.pdf");
}For Each employee In employees
Dim html As String = $"<h1>{employee.Name}</h1><p>Position: {employee.Position}</p><p>Age: {employee.Age}</p>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs($"{employee.Name}_Report.pdf")
Next employeeEn C#, les méthodes d'extension sont une manière puissante d'ajouter des fonctionnalités à des types existants sans modifier leur code source. Vous pouvez créer une méthode d'extension pour rationaliser les opérations sur un IEnumerable ou Liste.
Par exemple, créons une méthode d'extension pour obtenir le premier élément d'une collection enumerable.
public static class EnumerableExtensions
{
public static T FirstOrDefaultElement<t>(this IEnumerable<t> collection)
{
return collection?.FirstOrDefault();
}
}Imports System.Collections.Generic
Imports System.Linq
Public Module EnumerableExtensions
<System.Runtime.CompilerServices.Extension>
Public Function FirstOrDefaultElement(Of T)(collection As IEnumerable(Of T)) As T
Return If(collection?.FirstOrDefault(), Nothing)
End Function
End ModuleCommencez par configurer votre projet et initialiser IronPDF et la classe ChromePdfRenderer :
using IronPdf;
ChromePdfRenderer renderer = new ChromePdfRenderer();Imports IronPdf
Private renderer As New ChromePdfRenderer()Préparez vos données enumerables comme une chaîne HTML :
var employees = new List<Employee>
{
new Employee { Name = "John Doe", Position = "Developer", Age = 30 },
new Employee { Name = "Jane Smith", Position = "Designer", Age = 25 }
};
string html = "<table style='width:100%; border: 1px solid black;'>" +
"<tr><th>Name</th><th>Position</th><th>Age</th></tr>";
foreach (var employee in employees)
{
html += $"<tr><td>{employee.Name}</td><td>{employee.Position}</td><td>{employee.Age}</td></tr>";
}
html += "</table>";Dim employees = New List(Of Employee) From {
New Employee With {
.Name = "John Doe",
.Position = "Developer",
.Age = 30
},
New Employee With {
.Name = "Jane Smith",
.Position = "Designer",
.Age = 25
}
}
Dim html As String = "<table style='width:100%; border: 1px solid black;'>" & "<tr><th>Name</th><th>Position</th><th>Age</th></tr>"
For Each employee In employees
html &= $"<tr><td>{employee.Name}</td><td>{employee.Position}</td><td>{employee.Age}</td></tr>"
Next employee
html &= "</table>"Convertissez le HTML en un PDF :
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("Employees.pdf");Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("Employees.pdf")Maintenant que nous avons examiné de plus près comment vous pouvez utiliser la classe Enumerable de C# avec IronPDF pour générer des fichiers PDF, examinons un exemple de code complet dans lequel nous avons utilisé ces outils pour générer un nouveau document PDF dynamique.
using System;
using System.Collections.Generic;
using System.Linq;
using IronPdf;
public class Employee
{
public string Name { get; set; }
public string Position { get; set; }
public int Age { get; set; }
}
public class Program
{
public static void Main(string[] args)
{
// Sample employee data
var employees = new List<Employee>
{
new Employee { Name = "John Doe", Position = "Developer", Age = 30 },
new Employee { Name = "Jane Smith", Position = "Designer", Age = 25 },
new Employee { Name = "Sam Wilson", Position = "Manager", Age = 35 }
};
// Filter and sort data using LINQ
var filteredEmployees = employees
.Where(e => e.Age >= 25)
.OrderBy(e => e.Name)
.ToList();
// Generate HTML for the PDF
string html = "<h1 style='text-align:center;'>Employee Report</h1>" +
"<table style='width:100%; border-collapse: collapse;'>" +
"<tr style='background-color: #f2f2f2;'>" +
"<th style='border: 1px solid black; padding: 8px;'>Name</th>" +
"<th style='border: 1px solid black; padding: 8px;'>Position</th>" +
"<th style='border: 1px solid black; padding: 8px;'>Age</th></tr>";
foreach (var employee in filteredEmployees)
{
html += $"<tr>" +
$"<td style='border: 1px solid black; padding: 8px;'>{employee.Name}</td>" +
$"<td style='border: 1px solid black; padding: 8px;'>{employee.Position}</td>" +
$"<td style='border: 1px solid black; padding: 8px;'>{employee.Age}</td>" +
$"</tr>";
}
html += "</table>";
// Initialize ChromePdfRenderer
ChromePdfRenderer renderer = new ChromePdfRenderer();
// Render the HTML to a PDF
try
{
var pdf = renderer.RenderHtmlAsPdf(html);
string outputPath = "EmployeeReport.pdf";
pdf.SaveAs(outputPath);
Console.WriteLine($"PDF generated successfully at: {outputPath}");
}
catch (Exception ex)
{
Console.WriteLine($"Error generating PDF: {ex.Message}");
}
}
}Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports IronPdf
Public Class Employee
Public Property Name() As String
Public Property Position() As String
Public Property Age() As Integer
End Class
Public Class Program
Public Shared Sub Main(ByVal args() As String)
' Sample employee data
Dim employees = New List(Of Employee) From {
New Employee With {
.Name = "John Doe",
.Position = "Developer",
.Age = 30
},
New Employee With {
.Name = "Jane Smith",
.Position = "Designer",
.Age = 25
},
New Employee With {
.Name = "Sam Wilson",
.Position = "Manager",
.Age = 35
}
}
' Filter and sort data using LINQ
Dim filteredEmployees = employees.Where(Function(e) e.Age >= 25).OrderBy(Function(e) e.Name).ToList()
' Generate HTML for the PDF
Dim html As String = "<h1 style='text-align:center;'>Employee Report</h1>" & "<table style='width:100%; border-collapse: collapse;'>" & "<tr style='background-color: #f2f2f2;'>" & "<th style='border: 1px solid black; padding: 8px;'>Name</th>" & "<th style='border: 1px solid black; padding: 8px;'>Position</th>" & "<th style='border: 1px solid black; padding: 8px;'>Age</th></tr>"
For Each employee In filteredEmployees
html &= $"<tr>" & $"<td style='border: 1px solid black; padding: 8px;'>{employee.Name}</td>" & $"<td style='border: 1px solid black; padding: 8px;'>{employee.Position}</td>" & $"<td style='border: 1px solid black; padding: 8px;'>{employee.Age}</td>" & $"</tr>"
Next employee
html &= "</table>"
' Initialize ChromePdfRenderer
Dim renderer As New ChromePdfRenderer()
' Render the HTML to a PDF
Try
Dim pdf = renderer.RenderHtmlAsPdf(html)
Dim outputPath As String = "EmployeeReport.pdf"
pdf.SaveAs(outputPath)
Console.WriteLine($"PDF generated successfully at: {outputPath}")
Catch ex As Exception
Console.WriteLine($"Error generating PDF: {ex.Message}")
End Try
End Sub
End Class
Ce programme C# est conçu pour générer un rapport PDF de données d'employés filtrées en utilisant la bibliothèque IronPDF. Le code ci-dessus commence par définir une classe Employé avec des propriétés pour le Nom, le Poste et l'Âge, représentant des enregistrements d'employés individuels.
Une liste de données d'employés d'exemple est créée, consistant en trois objets Employé avec des noms, postes et âges différents. Le programme utilise alors LINQ pour filtrer cette liste, en sélectionnant uniquement les employés de 25 ans ou plus, et les trie par ordre alphabétique par nom. Cette liste filtrée et triée est stockée dans la variable filteredEmployees.
Ensuite, le programme construit une chaîne HTML qui sera utilisée pour générer le PDF. Il commence par un en-tête et une structure de tableau, définissant les en-têtes de colonne pour le Nom, le Poste et l'Âge. Il parcourt ensuite la liste des employés filtrés, générant dynamiquement des rangées de tableau pour les informations de chaque employé. Le HTML résultant est utilisé pour créer un PDF via le ChromePdfRenderer d'IronPDF.
L'exemple ci-dessus démontre efficacement comment utiliser IronPDF pour générer un PDF à partir de HTML généré dynamiquement, montrant la puissance de LINQ pour filtrer et trier les données, et gérer les exceptions de manière élégante pendant le processus de génération de PDF.
Utilisez LINQ pour optimiser le filtrage et les transformations sur vos données. Par exemple :
var filteredEmployees = employees.Where(e => e.Age > 25).OrderBy(e => e.Name);Dim filteredEmployees = employees.Where(Function(e) e.Age > 25).OrderBy(Function(e) e.Name)Minimisez les opérations redondantes en enchaînant efficacement les méthodes LINQ. Cela améliore les performances, surtout lorsque vous travaillez avec de grands ensembles de données.
Pour de grands ensembles de données, envisagez de diffuser les données en plus petits morceaux pour éviter les surcharges de mémoire. Utilisez yield return pour générer des collections de manière paresseuse, assurant une utilisation efficace de la mémoire.
IEnumerable<Employee> GetEmployees()
{
foreach (var employee in database.GetAllEmployees())
{
yield return employee;
}
}Private Iterator Function GetEmployees() As IEnumerable(Of Employee)
For Each employee In database.GetAllEmployees()
Yield employee
Next employee
End FunctionEnveloppez votre logique de génération de PDF dans un bloc try-catch pour gérer les erreurs de manière élégante :
try
{
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
}
catch (IronPdf.Exceptions.PdfException ex)
{
Console.WriteLine($"PDF Error: {ex.Message}");
}
catch (Exception ex)
{
Console.WriteLine($"General Error: {ex.Message}");
}Try
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
Catch ex As IronPdf.Exceptions.PdfException
Console.WriteLine($"PDF Error: {ex.Message}")
Catch ex As Exception
Console.WriteLine($"General Error: {ex.Message}")
End TryLa journalisation des erreurs et la fourniture de retours d'information conviviaux peuvent considérablement améliorer la robustesse de votre application.
L'intégration de l'IEnumerable de C# avec IronPDF débloque une manière efficace et flexible de générer des PDF professionnels par programmation. En tirant parti d'IEnumerable, vous pouvez rationaliser la transformation et le formatage des données tout en profitant de l'ensemble riche de fonctionnalités d'IronPDF pour produire des documents de haute qualité. Que vous exportiez des rapports de données, créiez des factures ou génériez du contenu personnalisé, cette combinaison assure l'évolutivité, les performances et la facilité d'utilisation.
Nous encourageons les développeurs à explorer des fonctionnalités plus avancées d'IronPDF, telles que l'intégration de multimédia ou la sécurisation des PDF, pour élever davantage leurs flux de travail d'automatisation de documents. Pour des informations supplémentaires, des didacticiels et une assistance, veuillez vous référer à la documentation IronPDF.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
