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

Installer IronPDF

Install-Package IronPdf

Concepts de base d'Enumerable en C

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.

Génération de PDF à partir de données Enumerables

Filtrer et transformer les données avant la génération de PDF

var activeEmployees = employees.Where(e => e.IsActive).Select(e => new {
    Name = e.Name.ToUpper(),
    Position = e.Position,
    Age = e.Age
});

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
})

Génération par lots de PDF à partir de Enumerables

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");
}

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 employee

Méthodes d'extension pour Enumerables

En 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();
    }
}

public static class EnumerableExtensions
{
    public static T FirstOrDefaultElement<T>(this IEnumerable<T> collection)
    {
        return collection?.FirstOrDefault();
    }
}

Public Module EnumerableExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Function FirstOrDefaultElement(Of T)(ByVal collection As IEnumerable(Of T)) As T
		Return collection?.FirstOrDefault()
	End Function
End Module

Configuration du projet

using IronPdf;
ChromePdfRenderer renderer = new ChromePdfRenderer();

using IronPdf;
ChromePdfRenderer renderer = new ChromePdfRenderer();

Imports IronPdf
Private renderer As New ChromePdfRenderer()

Conversion des Enumerables en contenu PDF

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>";

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>"

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("Employees.pdf");

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("Employees.pdf");

Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("Employees.pdf")

PDF de sortie

Explication du code

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.

Optimisation des opérations sur Enumerable

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);

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.

Utilisation efficace de la mémoire 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 paresseusement, garantissant une utilisation efficace de la mémoire.

IEnumerable<Employee> GetEmployees()
{
    foreach (var employee in database.GetAllEmployees())
    {
        yield return employee;
    }
}

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 Function

Gestion des erreurs lors de la génération de PDF

Enveloppez 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
{
    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 Try

La journalisation des erreurs et la fourniture de retours d'information conviviaux peuvent considérablement améliorer la robustesse de votre application.