A interface IEnumerable do C# é uma das ferramentas mais versáteis do .NET Framework, permitindo que os desenvolvedores trabalhem com coleções de maneira altamente flexível. Quando combinado com o IronPDF , o IEnumerable permite a manipulação dinâmica de dados e a geração eficiente de PDFs, tornando-o ideal para cenários como a criação de relatórios, a exportação de dados ou a geração de documentos a partir de consultas a bancos de dados.
O uso de IEnumerable garante que seu aplicativo permaneça escalável e eficiente em termos de memória, pois processa os dados de forma assíncrona e evita carregar conjuntos de dados inteiros na memória de uma só vez. Isso é especialmente útil para aplicações de grande escala que lidam com extensas coleções de dados, como uma tabela de banco de dados enorme.
IronPDF é uma poderosa biblioteca .NET projetada para simplificar o processo de criação, edição e gerenciamento programático de arquivos PDF. Oferece uma ampla gama de recursos, incluindo conversão de HTML para PDF, extração de texto, fusão de PDFs e muito mais. Ao integrar o IronPDF em seus projetos C#, você pode lidar de forma eficiente com tarefas complexas em PDF sem precisar de conhecimento profundo sobre o funcionamento interno do PDF.
O IronPDF também suporta uma variedade de formatos, permitindo gerar PDFs a partir de HTML bruto, Razor Views, páginas web ASP.NET ou até mesmo diretamente de estruturas de dados. Essa flexibilidade a torna uma ferramenta essencial para desenvolvedores que criam aplicativos modernos orientados a dados.
Para usar o IronPDF em seu projeto, siga estas etapas:
A interface IEnumerable representa uma sequência de elementos que podem ser enumerados. Exemplos comuns incluem matrizes, listas e resultados de consultas LINQ. Ao utilizar o LINQ, você pode filtrar, classificar e projetar dados no formato desejado antes de gerar PDFs com o IronPDF.
Uma das principais vantagens do IEnumerable é seu modelo de execução diferida, que permite que as consultas sejam executadas somente quando seus resultados forem acessados. Isso permite a manipulação eficiente de dados e reduz a sobrecarga computacional em fluxos de trabalho complexos.
Como uma lista implementa IEnumerable, qualquer coleção, como List, pode ser tratada como um IEnumerable, permitindo operações LINQ fáceis, filtragem e transformação.
Imagine que você tem uma lista de funcionários que implementa a interface IEnumerable e que precisa exportá-la como uma tabela em PDF. Usando IEnumerable e IronPDF, você pode iterar pelos dados e convertê-los em um PDF bem estruturado.
Para melhorar a apresentação, você pode usar tabelas HTML com CSS embutido para estilizar as linhas e colunas dinamicamente com base nos dados. Isso garante que o PDF gerado seja funcional e visualmente atraente.
Com o LINQ, você pode filtrar e transformar seus dados antes de passá-los para o IronPDF. Por exemplo, você pode filtrar apenas os funcionários ativos e formatar seus nomes em letras maiúsculas para a saída em 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
})Esses dados transformados podem então ser convertidos em um formato HTML compatível com PDF para renderização.
Se você precisar gerar um PDF separado para cada registro em uma coleção, poderá usar um loop foreach para iterar pela lista enumerável e gerar PDFs individuais dinamicamente. Isso é particularmente útil para criar faturas, certificados ou relatórios personalizados.
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 employeeEm C#, os métodos de extensão são uma maneira poderosa de adicionar funcionalidades a tipos existentes sem modificar seu código-fonte. Você pode criar um método de extensão para simplificar as operações em um IEnumerable ou List .
Por exemplo, vamos criar um método de extensão para obter o primeiro elemento de uma coleção enumerável.
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 ModuleComece configurando seu projeto e inicializando o IronPDF e a classe ChromePdfRenderer :
using IronPdf;
ChromePdfRenderer renderer = new ChromePdfRenderer();Imports IronPdf
Private renderer As New ChromePdfRenderer()Prepare seus dados enumeráveis como uma string 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>"Converter HTML para PDF:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("Employees.pdf");Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("Employees.pdf")Agora que analisamos mais detalhadamente como você pode usar a classe Enumerable do C# com o IronPDF para gerar arquivos PDF, vamos examinar um exemplo de código completo no qual usamos essas ferramentas para gerar um novo documento PDF dinâmico.
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
Este programa em C# foi desenvolvido para gerar um relatório em PDF com dados filtrados de funcionários, utilizando a biblioteca IronPDF . O código acima começa definindo uma classe Employee com propriedades para Nome, Cargo e Idade, representando registros individuais de funcionários.
É criada uma lista de dados de funcionários de exemplo, composta por três objetos "Funcionário" com nomes, cargos e idades diferentes. Em seguida, o programa usa LINQ para filtrar essa lista, selecionando apenas os funcionários com 25 anos ou mais e os classificando em ordem alfabética por nome. Essa lista filtrada e ordenada é armazenada na variável filteredEmployees.
Em seguida, o programa constrói uma string HTML que será usada para gerar o PDF. Começa com um cabeçalho e uma estrutura de tabela, definindo os cabeçalhos das colunas para Nome, Cargo e Idade. Em seguida, o programa percorre a lista filtrada de funcionários, gerando dinamicamente linhas de tabela para as informações de cada funcionário. O HTML resultante é usado para criar um PDF através do ChromePdfRenderer do IronPDF.
O exemplo acima demonstra de forma eficaz como usar o IronPDF para gerar um PDF a partir de HTML gerado dinamicamente, mostrando o poder do LINQ para filtrar e classificar dados, e lidando com exceções de forma adequada durante o processo de geração do PDF.
Utilize LINQ para otimizar a filtragem e as transformações dos seus dados. Por exemplo:
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)Minimize operações redundantes encadeando métodos LINQ de forma eficaz. Isso melhora o desempenho, especialmente ao trabalhar com grandes conjuntos de dados.
Para conjuntos de dados grandes, considere dividir os dados em partes menores para evitar sobrecarga de memória. Utilize yield return para gerar coleções de forma preguiçosa, garantindo o uso eficiente da memória.
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 FunctionEnvolva sua lógica de geração de PDF em um bloco try-catch para lidar com erros de forma adequada:
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 TryRegistrar erros e fornecer feedback amigável ao usuário pode melhorar significativamente a robustez do seu aplicativo.
A integração da classe IEnumerable do C# com o IronPDF oferece uma maneira eficiente e flexível de gerar PDFs profissionais programaticamente. Ao utilizar o IEnumerable, você pode simplificar a transformação e a formatação de dados, aproveitando ao mesmo tempo o rico conjunto de recursos do IronPDF para produzir documentos de alta qualidade. Seja para exportar relatórios de dados, criar faturas ou gerar conteúdo personalizado, essa combinação garante escalabilidade, desempenho e facilidade de uso.
Incentivamos os desenvolvedores a explorar recursos mais avançados do IronPDF, como incorporar conteúdo multimídia ou proteger PDFs, para aprimorar ainda mais seus fluxos de trabalho de automação de documentos. Para obter informações adicionais, tutoriais e suporte, consulte a Documentação do IronPDF .
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
