Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Ajuda do .NET
  4. ObservableCollection em C#
AJUDA DO .NET

ObservableCollection em C# (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

Em C#, a ObservableCollection É uma estrutura de dados poderosa que notifica automaticamente os ouvintes quando itens são adicionados, removidos ou alterados. É particularmente útil em cenários de coleta de dados dinâmicos, como quando você precisa refletir alterações em tempo real na sua interface de usuário ou em relatórios. Quando combinada com o IronPDF, essa poderosa coleção pode ser usada para gerar PDFs dinâmicos com base em dados em tempo real.

IronPDF é uma biblioteca robusta para gerar PDFs em C#. Com seus recursos de conversão de HTML para PDF , é fácil criar PDFs de alta qualidade, seja para gerar faturas, relatórios ou qualquer outro documento baseado em dados em tempo real. Neste artigo, mostraremos como integrar a classe ObservableCollection com o IronPDF, aproveitando o data binding para gerar um PDF que se atualiza dinamicamente conforme os dados mudam.

Entendendo a ObservableCollection

O que é uma ObservableCollection?

A Coleção Observável É uma classe em C# que implementa a interface INotifyCollectionChanged, a qual fornece notificações quando itens são adicionados, removidos ou modificados. É comumente usado para vinculação de dados em aplicativos de interface do usuário como o WPF, onde as alterações na coleção acionam automaticamente atualizações na interface do usuário. Ao contrário de outras coleções como a Lista Uma ObservableCollection oferece notificações de eventos integradas, tornando-a perfeita para cenários em que os dados precisam ser refletidos em tempo real.

O ObservableCollection lida automaticamente com as alterações em toda a coleção, facilitando o gerenciamento e a exibição de coleções de dados dinâmicas em sua aplicação.

Casos de uso comuns

  • Vinculação a componentes de interface do usuário: No WPF, por exemplo, o ObservableCollection é frequentemente usado para vincular dados a controles como ListView, DataGrid e ComboBox. Quando a coleção subjacente é alterada, a interface do usuário é atualizada automaticamente.
  • Atualizações em tempo real: Quando os dados mudam com frequência, o ObservableCollection garante que a interface do usuário esteja sempre sincronizada. Por exemplo, você poderia usá-lo para um relatório em tempo real, onde novas entradas de dados são adicionadas à coleção instantaneamente, e o relatório é atualizado de acordo.
  • Alterações dinâmicas: Se o seu aplicativo permite que os usuários adicionem, excluam ou modifiquem dados, o ObservableCollection pode ser usado para refletir automaticamente essas alterações na interface do usuário ou em outros componentes.

Trabalhando com o IronPDF

Visão geral do IronPDF

ObservableCollection em C# (Como funciona para desenvolvedores): Figura 1

Como mencionamos no início deste artigo, o IronPDF é uma biblioteca .NET para geração de PDFs que facilita a criação, modificação e renderização de documentos PDF. Diferentemente de algumas outras bibliotecas de PDF, o IronPDF oferece um conjunto abrangente de recursos que simplificam o trabalho com PDFs, como a conversão de HTML para PDF, a adição de marcas d'água, a manipulação de PDFs existentes e muito mais.

O IronPDF também permite que os desenvolvedores renderizem PDFs a partir de diferentes fontes de dados, incluindo HTML, imagens e texto simples, o que pode ser particularmente útil quando você precisa apresentar dados dinâmicos. Com a API do IronPDF, você pode gerar PDFs de alta qualidade, incluindo layouts detalhados, tabelas, imagens e estilos.

Configuração do IronPDF

Para começar a usar o IronPDF, você precisa instalar a biblioteca via NuGet. Você pode adicioná-lo ao seu projeto executando o seguinte comando no Console do Gerenciador de Pacotes:

Install-Package IronPdf

Após a instalação, você pode inicializar o IronPDF e usar seus recursos avançados. Neste artigo, vamos nos concentrar na geração de PDFs a partir de dados dinâmicos em uma ObservableCollection.

Integrando ObservableCollection com IronPDF

Caso de uso: Geração dinâmica de PDFs a partir de ObservableCollection

Vamos imaginar um cenário em que você precisa gerar um PDF de fatura a partir de uma lista de itens armazenados em uma ObservableCollection. À medida que itens são adicionados ou removidos da coleção, o PDF deve ser regenerado automaticamente para refletir o estado atual dos dados.

Para esta tarefa, o ObservableCollection oferece uma maneira fácil de gerenciar os itens da fatura, enquanto o IronPDF nos permitirá gerar e exportar a fatura para o formato PDF.

Vinculação de dados ao conteúdo do PDF

Para vincular os dados de uma ObservableCollection a um PDF, você precisa percorrer a coleção em um loop e adicionar seus itens ao conteúdo do PDF. O IronPDF oferece métodos para criar tabelas, adicionar texto e personalizar o layout, facilitando a representação dos dados em um formato estruturado.

Por exemplo, se você tiver uma fatura com vários itens, poderá gerar o PDF dinamicamente percorrendo a ObservableCollection e adicionando cada item a uma tabela ou lista no documento. O IronPDF permite um alto nível de personalização, incluindo o ajuste de fontes, bordas e até mesmo a inclusão de imagens como logotipos ou códigos de barras.

Exemplo Um: Gerando um PDF usando ObservableCollection

Vejamos um exemplo simples para demonstrar como isso funciona. Suponha que você tenha uma coleção de pessoas (representadas pela classe Pessoa) e queira gerar um PDF que reflita os detalhes dessas pessoas. Cada vez que uma nova pessoa for adicionada à coleção, o PDF será atualizado automaticamente.

Exemplo de classe Pessoa

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
Public Class Person
	Public Property Name() As String
	Public Property Age() As Integer
End Class
$vbLabelText   $csharpLabel

Neste caso, a classe Pessoa contém propriedades básicas como Nome e Idade. Usaremos essa classe em conjunto com a ObservableCollection para gerar um PDF dinamicamente.

Criando a ObservableCollection

using System.Collections.ObjectModel;

var collection = new ObservableCollection<Person>
{
    new Person { Name = "John Doe", Age = 30 },
    new Person { Name = "Jane Smith", Age = 28 }
};
using System.Collections.ObjectModel;

var collection = new ObservableCollection<Person>
{
    new Person { Name = "John Doe", Age = 30 },
    new Person { Name = "Jane Smith", Age = 28 }
};
Imports System.Collections.ObjectModel

Private collection = New ObservableCollection(Of Person) From {
	New Person With {
		.Name = "John Doe",
		.Age = 30
	},
	New Person With {
		.Name = "Jane Smith",
		.Age = 28
	}
}
$vbLabelText   $csharpLabel

Esta ObservableCollection contém uma coleção de objetos Person, cada um com um Nome e uma Idade. Quando um item é adicionado ou removido, os manipuladores de eventos são acionados, os quais usaremos para atualizar o PDF dinamicamente.

Adicionando manipuladores de eventos para alterações de coleção

Neste exemplo, nos inscrevemos no evento CollectionChanged da classe ObservableCollection para regenerar automaticamente o PDF sempre que a coleção for alterada. Isso é útil se você precisar responder a alterações, como adicionar ou remover um objeto Pessoa.

// Subscribe to the ObservableCollection's CollectionChanged event
collection.CollectionChanged += (object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) =>
{
    // Regenerate the PDF whenever the collection changes
    GeneratePersonPDF(collection);
};
// Subscribe to the ObservableCollection's CollectionChanged event
collection.CollectionChanged += (object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) =>
{
    // Regenerate the PDF whenever the collection changes
    GeneratePersonPDF(collection);
};
' Subscribe to the ObservableCollection's CollectionChanged event
AddHandler collection.CollectionChanged, Sub(sender As Object, e As System.Collections.Specialized.NotifyCollectionChangedEventArgs)
	' Regenerate the PDF whenever the collection changes
	GeneratePersonPDF(collection)
End Sub
$vbLabelText   $csharpLabel

Adicionando novas pessoas à coleção

Você pode adicionar uma nova Pessoa à coleção, e toda a coleção acionará o manipulador de eventos para regenerar o PDF. Essa abordagem lida automaticamente com as alterações em toda a lista de pessoas.

// Adding a new person to the collection
collection.Add(new Person { Name = "Alice Brown", Age = 32 });
// Adding a new person to the collection
collection.Add(new Person { Name = "Alice Brown", Age = 32 });
' Adding a new person to the collection
collection.Add(New Person With {
	.Name = "Alice Brown",
	.Age = 32
})
$vbLabelText   $csharpLabel

Cada vez que você adicionar uma nova pessoa à coleção, o PDF será regenerado, incluindo a nova entrada.

Propriedade de Idade Vinculativa

Você também pode vincular a propriedade de idade de uma Pessoa a algum sistema externo (como a interface do usuário ou outras partes do aplicativo) para que as alterações sejam refletidas automaticamente.

Aqui está um exemplo de como a propriedade Idade seria vinculada na classe Pessoa:

public class Person
{
    public string Name { get; set; }
    private int _age;
    public int Age 
    {
        get { return _age; }
        set
        {
            _age = value;
            // Raise property changed event here if using data binding
        }
    }
}
public class Person
{
    public string Name { get; set; }
    private int _age;
    public int Age 
    {
        get { return _age; }
        set
        {
            _age = value;
            // Raise property changed event here if using data binding
        }
    }
}
Public Class Person
	Public Property Name() As String
	Private _age As Integer
	Public Property Age() As Integer
		Get
			Return _age
		End Get
		Set(ByVal value As Integer)
			_age = value
			' Raise property changed event here if using data binding
		End Set
	End Property
End Class
$vbLabelText   $csharpLabel

Utilizando ObservableCollection com Binding

Vamos demonstrar como vincular a idade a um elemento da interface do usuário, atualizando o valor da idade e observando as alterações refletidas na coleção:

ObservableCollection<Person> people = new ObservableCollection<Person>
{
    new Person { Name = "John", Age = 30 },
    new Person { Name = "Jane", Age = 28 }
};
// Binding the Age of the first person to a UI element (pseudo-code)
someUIElement.Text = people[0].Age.ToString();
ObservableCollection<Person> people = new ObservableCollection<Person>
{
    new Person { Name = "John", Age = 30 },
    new Person { Name = "Jane", Age = 28 }
};
// Binding the Age of the first person to a UI element (pseudo-code)
someUIElement.Text = people[0].Age.ToString();
Dim people As New ObservableCollection(Of Person) From {
	New Person With {
		.Name = "John",
		.Age = 30
	},
	New Person With {
		.Name = "Jane",
		.Age = 28
	}
}
' Binding the Age of the first person to a UI element (pseudo-code)
someUIElement.Text = people(0).Age.ToString()
$vbLabelText   $csharpLabel

Gerando o PDF com o IronPDF

Agora que configuramos a ObservableCollection e adicionamos os manipuladores de eventos, é hora de nos concentrarmos em gerar um PDF que reflita a coleção dinâmica de pessoas.

using IronPdf;

public void GeneratePersonPDF(ObservableCollection<Person> people)
{
    var pdf = new ChromePdfRenderer();  // Initialize IronPDF's ChromePdfRenderer class
    // Create HTML content representing the people in the collection
    var htmlContent = "<h1>People Information</h1><table border='1' cellpadding='5' cellspacing='0'>" +
                      "<tr><th>Name</th><th>Age</th></tr>";
    foreach (var person in people)
    {
        htmlContent += $"<tr><td>{person.Name}</td><td>{person.Age}</td></tr>";
    }

    htmlContent += "</table>";
    // Convert the HTML content to a PDF
    var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
    // Save the generated PDF to disk
    pdfDocument.SaveAs("PeopleInformation.pdf");
}
using IronPdf;

public void GeneratePersonPDF(ObservableCollection<Person> people)
{
    var pdf = new ChromePdfRenderer();  // Initialize IronPDF's ChromePdfRenderer class
    // Create HTML content representing the people in the collection
    var htmlContent = "<h1>People Information</h1><table border='1' cellpadding='5' cellspacing='0'>" +
                      "<tr><th>Name</th><th>Age</th></tr>";
    foreach (var person in people)
    {
        htmlContent += $"<tr><td>{person.Name}</td><td>{person.Age}</td></tr>";
    }

    htmlContent += "</table>";
    // Convert the HTML content to a PDF
    var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
    // Save the generated PDF to disk
    pdfDocument.SaveAs("PeopleInformation.pdf");
}
Imports IronPdf

Public Sub GeneratePersonPDF(ByVal people As ObservableCollection(Of Person))
	Dim pdf = New ChromePdfRenderer() ' Initialize IronPDF's ChromePdfRenderer class
	' Create HTML content representing the people in the collection
	Dim htmlContent = "<h1>People Information</h1><table border='1' cellpadding='5' cellspacing='0'>" & "<tr><th>Name</th><th>Age</th></tr>"
	For Each person In people
		htmlContent &= $"<tr><td>{person.Name}</td><td>{person.Age}</td></tr>"
	Next person

	htmlContent &= "</table>"
	' Convert the HTML content to a PDF
	Dim pdfDocument = pdf.RenderHtmlAsPdf(htmlContent)
	' Save the generated PDF to disk
	pdfDocument.SaveAs("PeopleInformation.pdf")
End Sub
$vbLabelText   $csharpLabel

Exemplo Dois: Gerando uma fatura em PDF a partir de uma ObservableCollection

Aqui está um exemplo de como gerar um PDF a partir de uma ObservableCollection de itens de fatura usando o IronPDF:

Etapa 1: Exemplo de Classe de Item de Fatura

Esta classe representa um item na fatura, com propriedades para nome do item, quantidade, preço e preço total.

public class InvoiceItem
{
    public string ItemName { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }
    public decimal Total => Quantity * Price;
}
public class InvoiceItem
{
    public string ItemName { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }
    public decimal Total => Quantity * Price;
}
Public Class InvoiceItem
	Public Property ItemName() As String
	Public Property Quantity() As Integer
	Public Property Price() As Decimal
	Public ReadOnly Property Total() As Decimal
		Get
			Return Quantity * Price
		End Get
	End Property
End Class
$vbLabelText   $csharpLabel

Etapa 2: Exemplo de ObservableCollection

Este exemplo inicializa uma ObservableCollection contendo vários itens de fatura. Você pode adicionar, remover ou modificar itens nesta coleção dinamicamente.

ObservableCollection<InvoiceItem> invoiceItems = new ObservableCollection<InvoiceItem>
{
    new InvoiceItem { ItemName = "Item 1", Quantity = 2, Price = 10.00m },
    new InvoiceItem { ItemName = "Item 2", Quantity = 1, Price = 25.00m },
    new InvoiceItem { ItemName = "Item 3", Quantity = 5, Price = 5.00m }
};
ObservableCollection<InvoiceItem> invoiceItems = new ObservableCollection<InvoiceItem>
{
    new InvoiceItem { ItemName = "Item 1", Quantity = 2, Price = 10.00m },
    new InvoiceItem { ItemName = "Item 2", Quantity = 1, Price = 25.00m },
    new InvoiceItem { ItemName = "Item 3", Quantity = 5, Price = 5.00m }
};
Dim invoiceItems As New ObservableCollection(Of InvoiceItem) From {
	New InvoiceItem With {
		.ItemName = "Item 1",
		.Quantity = 2,
		.Price = 10.00D
	},
	New InvoiceItem With {
		.ItemName = "Item 2",
		.Quantity = 1,
		.Price = 25.00D
	},
	New InvoiceItem With {
		.ItemName = "Item 3",
		.Quantity = 5,
		.Price = 5.00D
	}
}
$vbLabelText   $csharpLabel

Etapa 3: Gerando o PDF com o IronPDF

Aqui, criamos uma função para gerar o PDF. Esta função utiliza os dados da ObservableCollection e os converte em HTML, que é então renderizado como um PDF usando o IronPDF.

public void GenerateInvoicePDF(ObservableCollection<InvoiceItem> items)
{
    var pdf = new ChromePdfRenderer();  // Initialize IronPDF's ChromePdfRenderer class
    // Create HTML content representing the invoice
    var htmlContent = "<h1>Invoice</h1><table border='1' cellpadding='5' cellspacing='0'>" +
                      "<tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>";
    foreach (var item in items)
    {
        htmlContent += $"<tr><td>{item.ItemName}</td><td>{item.Quantity}</td><td>{item.Price:C}</td><td>{item.Total:C}</td></tr>";
    }
    htmlContent += "</table>";
    // Convert the HTML content to a PDF
    var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
    // Save the generated PDF to disk
    pdfDocument.SaveAs("Invoice.pdf");
}
public void GenerateInvoicePDF(ObservableCollection<InvoiceItem> items)
{
    var pdf = new ChromePdfRenderer();  // Initialize IronPDF's ChromePdfRenderer class
    // Create HTML content representing the invoice
    var htmlContent = "<h1>Invoice</h1><table border='1' cellpadding='5' cellspacing='0'>" +
                      "<tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>";
    foreach (var item in items)
    {
        htmlContent += $"<tr><td>{item.ItemName}</td><td>{item.Quantity}</td><td>{item.Price:C}</td><td>{item.Total:C}</td></tr>";
    }
    htmlContent += "</table>";
    // Convert the HTML content to a PDF
    var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
    // Save the generated PDF to disk
    pdfDocument.SaveAs("Invoice.pdf");
}
Public Sub GenerateInvoicePDF(ByVal items As ObservableCollection(Of InvoiceItem))
	Dim pdf = New ChromePdfRenderer() ' Initialize IronPDF's ChromePdfRenderer class
	' Create HTML content representing the invoice
	Dim htmlContent = "<h1>Invoice</h1><table border='1' cellpadding='5' cellspacing='0'>" & "<tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>"
	For Each item In items
		htmlContent &= $"<tr><td>{item.ItemName}</td><td>{item.Quantity}</td><td>{item.Price:C}</td><td>{item.Total:C}</td></tr>"
	Next item
	htmlContent &= "</table>"
	' Convert the HTML content to a PDF
	Dim pdfDocument = pdf.RenderHtmlAsPdf(htmlContent)
	' Save the generated PDF to disk
	pdfDocument.SaveAs("Invoice.pdf")
End Sub
$vbLabelText   $csharpLabel

Passo 4: Inscreva-se no evento CollectionChanged

Como o ObservableCollection notifica automaticamente as alterações, você pode facilmente regenerar o PDF sempre que a coleção for atualizada. Por exemplo, se um item for adicionado ou removido, o PDF poderá ser regenerado com os dados atualizados.

Veja como você pode se inscrever no evento CollectionChanged e regenerar o PDF sempre que a coleção for alterada:

// Subscribe to the ObservableCollection's CollectionChanged event
invoiceItems.CollectionChanged += (sender, e) =>
{
    // Regenerate the PDF whenever the collection changes
    GenerateInvoicePDF(invoiceItems);
};
// Subscribe to the ObservableCollection's CollectionChanged event
invoiceItems.CollectionChanged += (sender, e) =>
{
    // Regenerate the PDF whenever the collection changes
    GenerateInvoicePDF(invoiceItems);
};
' Subscribe to the ObservableCollection's CollectionChanged event
AddHandler invoiceItems.CollectionChanged, Sub(sender, e)
	' Regenerate the PDF whenever the collection changes
	GenerateInvoicePDF(invoiceItems)
End Sub
$vbLabelText   $csharpLabel

Etapa 5: Adicionando itens e testando

Agora você pode testar adicionando novos itens à ObservableCollection e observando como o PDF é regenerado automaticamente.

// Adding a new item to the ObservableCollection
invoiceItems.Add(new InvoiceItem { ItemName = "Item 4", Quantity = 3, Price = 12.50m });
// Adding a new item to the ObservableCollection
invoiceItems.Add(new InvoiceItem { ItemName = "Item 4", Quantity = 3, Price = 12.50m });
' Adding a new item to the ObservableCollection
invoiceItems.Add(New InvoiceItem With {
	.ItemName = "Item 4",
	.Quantity = 3,
	.Price = 12.50D
})
$vbLabelText   $csharpLabel

Exemplo de código completo

using System;
using System.Collections.ObjectModel;
using IronPdf;

public class InvoiceItem
{
    public string ItemName { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }
    // Property to calculate the total price for each item
    public decimal Total => Quantity * Price;
}
public class InvoiceGenerator
{
    // Function to generate the invoice PDF
    public void GenerateInvoicePDF(ObservableCollection<InvoiceItem> items)
    {
        var pdf = new ChromePdfRenderer();  // Initialize IronPDF's ChromePdfRenderer class
        // Create HTML content representing the invoice
        var htmlContent = "<h1>Invoice</h1><table border='1' cellpadding='5' cellspacing='0'>" +
                          "<tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>";
        foreach (var item in items)
        {
            htmlContent += $"<tr><td>{item.ItemName}</td><td>{item.Quantity}</td><td>{item.Price:C}</td><td>{item.Total:C}</td></tr>";
        }
        htmlContent += "</table>";
        // Convert the HTML content to a PDF
        var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
        // Save the generated PDF to disk
        pdfDocument.SaveAs("Invoice.pdf");
    }

    // Main function to test the code
    public static void Main(string[] args)
    {
        var invoiceItems = new ObservableCollection<InvoiceItem>
        {
            new InvoiceItem { ItemName = "Item 1", Quantity = 2, Price = 10.00m },
            new InvoiceItem { ItemName = "Item 2", Quantity = 1, Price = 25.00m },
            new InvoiceItem { ItemName = "Item 3", Quantity = 5, Price = 5.00m }
        };

        var invoiceGenerator = new InvoiceGenerator();

        // Subscribe to the ObservableCollection's CollectionChanged event
        invoiceItems.CollectionChanged += (sender, e) =>
        {
            // Regenerate the PDF whenever the collection changes
            invoiceGenerator.GenerateInvoicePDF(invoiceItems);
        };

        // Generate initial PDF
        invoiceGenerator.GenerateInvoicePDF(invoiceItems);

        // Add a new item to the collection and automatically regenerate the PDF
        invoiceItems.Add(new InvoiceItem { ItemName = "Item 4", Quantity = 3, Price = 12.50m });

        // Remove an item and see the PDF update
        invoiceItems.RemoveAt(0);
    }
}
using System;
using System.Collections.ObjectModel;
using IronPdf;

public class InvoiceItem
{
    public string ItemName { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }
    // Property to calculate the total price for each item
    public decimal Total => Quantity * Price;
}
public class InvoiceGenerator
{
    // Function to generate the invoice PDF
    public void GenerateInvoicePDF(ObservableCollection<InvoiceItem> items)
    {
        var pdf = new ChromePdfRenderer();  // Initialize IronPDF's ChromePdfRenderer class
        // Create HTML content representing the invoice
        var htmlContent = "<h1>Invoice</h1><table border='1' cellpadding='5' cellspacing='0'>" +
                          "<tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>";
        foreach (var item in items)
        {
            htmlContent += $"<tr><td>{item.ItemName}</td><td>{item.Quantity}</td><td>{item.Price:C}</td><td>{item.Total:C}</td></tr>";
        }
        htmlContent += "</table>";
        // Convert the HTML content to a PDF
        var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
        // Save the generated PDF to disk
        pdfDocument.SaveAs("Invoice.pdf");
    }

    // Main function to test the code
    public static void Main(string[] args)
    {
        var invoiceItems = new ObservableCollection<InvoiceItem>
        {
            new InvoiceItem { ItemName = "Item 1", Quantity = 2, Price = 10.00m },
            new InvoiceItem { ItemName = "Item 2", Quantity = 1, Price = 25.00m },
            new InvoiceItem { ItemName = "Item 3", Quantity = 5, Price = 5.00m }
        };

        var invoiceGenerator = new InvoiceGenerator();

        // Subscribe to the ObservableCollection's CollectionChanged event
        invoiceItems.CollectionChanged += (sender, e) =>
        {
            // Regenerate the PDF whenever the collection changes
            invoiceGenerator.GenerateInvoicePDF(invoiceItems);
        };

        // Generate initial PDF
        invoiceGenerator.GenerateInvoicePDF(invoiceItems);

        // Add a new item to the collection and automatically regenerate the PDF
        invoiceItems.Add(new InvoiceItem { ItemName = "Item 4", Quantity = 3, Price = 12.50m });

        // Remove an item and see the PDF update
        invoiceItems.RemoveAt(0);
    }
}
Imports System
Imports System.Collections.ObjectModel
Imports IronPdf

Public Class InvoiceItem
	Public Property ItemName() As String
	Public Property Quantity() As Integer
	Public Property Price() As Decimal
	' Property to calculate the total price for each item
	Public ReadOnly Property Total() As Decimal
		Get
			Return Quantity * Price
		End Get
	End Property
End Class
Public Class InvoiceGenerator
	' Function to generate the invoice PDF
	Public Sub GenerateInvoicePDF(ByVal items As ObservableCollection(Of InvoiceItem))
		Dim pdf = New ChromePdfRenderer() ' Initialize IronPDF's ChromePdfRenderer class
		' Create HTML content representing the invoice
		Dim htmlContent = "<h1>Invoice</h1><table border='1' cellpadding='5' cellspacing='0'>" & "<tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>"
		For Each item In items
			htmlContent &= $"<tr><td>{item.ItemName}</td><td>{item.Quantity}</td><td>{item.Price:C}</td><td>{item.Total:C}</td></tr>"
		Next item
		htmlContent &= "</table>"
		' Convert the HTML content to a PDF
		Dim pdfDocument = pdf.RenderHtmlAsPdf(htmlContent)
		' Save the generated PDF to disk
		pdfDocument.SaveAs("Invoice.pdf")
	End Sub

	' Main function to test the code
	Public Shared Sub Main(ByVal args() As String)
		Dim invoiceItems = New ObservableCollection(Of InvoiceItem) From {
			New InvoiceItem With {
				.ItemName = "Item 1",
				.Quantity = 2,
				.Price = 10.00D
			},
			New InvoiceItem With {
				.ItemName = "Item 2",
				.Quantity = 1,
				.Price = 25.00D
			},
			New InvoiceItem With {
				.ItemName = "Item 3",
				.Quantity = 5,
				.Price = 5.00D
			}
		}

'INSTANT VB NOTE: The variable invoiceGenerator was renamed since it may cause conflicts with calls to static members of the user-defined type with this name:
		Dim invoiceGenerator_Conflict As New InvoiceGenerator()

		' Subscribe to the ObservableCollection's CollectionChanged event
		AddHandler invoiceItems.CollectionChanged, Sub(sender, e)
			' Regenerate the PDF whenever the collection changes
			invoiceGenerator_Conflict.GenerateInvoicePDF(invoiceItems)
		End Sub

		' Generate initial PDF
		invoiceGenerator_Conflict.GenerateInvoicePDF(invoiceItems)

		' Add a new item to the collection and automatically regenerate the PDF
		invoiceItems.Add(New InvoiceItem With {
			.ItemName = "Item 4",
			.Quantity = 3,
			.Price = 12.50D
		})

		' Remove an item and see the PDF update
		invoiceItems.RemoveAt(0)
	End Sub
End Class
$vbLabelText   $csharpLabel

Saída

ObservableCollection em C# (Como funciona para desenvolvedores): Figura 2 - Arquivo PDF de saída

O que o código faz

  • Classe InvoiceItem: Representa um item de fatura com propriedades para ItemName, Quantity, Price e um Total calculado.
  • ObservableCollection: Usada para armazenar a lista de itens da fatura. A coleção notifica automaticamente os ouvintes sobre quaisquer alterações (por exemplo, quando itens são adicionados ou removidos).
  • GenerateInvoicePDF: Este método cria o conteúdo HTML que representa a fatura e usa o IronPDF para convertê-lo em um arquivo PDF.
  • CollectionChanged: O evento ObservableCollection é tratado para regenerar o PDF sempre que a coleção for alterada, tornando a geração do PDF dinâmica.
  • Teste: O método Main demonstra como adicionar e remover itens da ObservableCollection aciona a regeneração do PDF.

Considerações sobre o desempenho

Lidar com grandes coleções

Ao trabalhar com instâncias grandes de ObservableCollection, o desempenho pode se tornar uma preocupação. Gerar um novo PDF sempre que a coleção for alterada pode consumir muitos recursos se houver um grande número de itens. Para mitigar esse problema, considere agrupar as atualizações ou usar técnicas como paginação para evitar sobrecarregar o processo de geração de PDFs.

Renderização eficiente de PDFs

Para garantir que a renderização de PDFs seja eficiente, tenha em mente as seguintes dicas:

  • Minimize renderizações desnecessárias: Regenere o PDF somente quando os dados mudarem significativamente (por exemplo, quando itens forem adicionados ou removidos).
  • Otimize o layout da tabela: ao renderizar grandes conjuntos de dados, divida-os em seções menores e mais gerenciáveis ​​para melhorar o tempo de renderização.
  • Utilize o cache: Armazene em cache os PDFs gerados anteriormente para dados estáticos ou que mudam com pouca frequência.

Conclusão

Ao combinar a ObservableCollection do C# com o IronPDF , você pode gerar facilmente PDFs dinâmicos que refletem as alterações em tempo real nos dados do seu aplicativo. Seja para gerar faturas, relatórios ou outros documentos, essa abordagem permite atualizar automaticamente o conteúdo do PDF sempre que a coleção subjacente for alterada.

A integração do ObservableCollection garante que seu aplicativo esteja sempre atualizado com o mínimo esforço, enquanto o IronPDF cuida da parte mais complexa de renderizar PDFs de alta qualidade. Seguindo as melhores práticas e dicas de desempenho discutidas neste artigo, você pode criar uma experiência de geração de PDFs perfeita para seus aplicativos .NET .

Quer experimentar o IronPDF você mesmo? Baixe a versão de avaliação gratuita hoje mesmo para aprimorar seus projetos de PDF em C# e não deixe de conferir a extensa seção de documentação para ver mais desta biblioteca em ação.

Perguntas frequentes

O que é uma ObservableCollection em C#?

A ObservableCollection é uma classe em C# que implementa a interface INotifyCollectionChanged. Ela fornece notificações quando itens são adicionados, removidos ou modificados, tornando-a ideal para vinculação de dados em aplicativos de interface do usuário onde atualizações em tempo real são necessárias.

Como posso gerar um PDF a partir de dados dinâmicos em C#?

Usando o IronPDF, você pode gerar PDFs a partir de dados dinâmicos, aproveitando a ObservableCollection do C#. À medida que a coleção é atualizada, você pode regenerar automaticamente o PDF para refletir o estado atual dos dados.

Quais são os benefícios de usar ObservableCollection com geração de PDF?

A ObservableCollection permite o rastreamento de dados em tempo real, o que é benéfico ao gerar PDFs que precisam refletir alterações de dados ao vivo. Combinado com o IronPDF, garante que quaisquer atualizações nos dados sejam prontamente refletidas na saída em PDF.

Como vincular dados de uma ObservableCollection a um PDF em C#?

Você pode vincular dados de uma ObservableCollection a um PDF iterando sobre os itens da coleção e usando os métodos do IronPDF para adicioná-los ao PDF como elementos estruturados, como tabelas ou listas. Isso garante que o conteúdo do PDF esteja sempre sincronizado com os dados.

Qual é um caso de uso comum para gerar PDFs com ObservableCollection em C#?

Um caso de uso comum é a geração de faturas a partir de uma ObservableCollection de itens. À medida que itens são adicionados ou removidos da coleção, a fatura em PDF pode ser regenerada para refletir com precisão a lista atual de itens, garantindo documentação atualizada.

Como o IronPDF lida com a conversão de HTML para PDF em C#?

O IronPDF pode converter HTML em PDF usando métodos como RenderHtmlAsPdf e RenderHtmlFileAsPdf . Isso permite que os desenvolvedores criem PDFs a partir de páginas da web ou strings HTML, facilitando a renderização de conteúdo dinâmico.

O que deve ser considerado ao trabalhar com grandes ObservableCollections para geração de PDFs?

Ao lidar com grandes coleções, considere usar paginação, atualizações em lote e otimização do layout para evitar problemas de desempenho. Os recursos de cache e otimização de renderização do IronPDF também podem ajudar a gerenciar grandes volumes de dados com eficiência.

Como o IronPDF pode aumentar a produtividade em aplicações .NET?

O IronPDF aumenta a produtividade ao fornecer recursos robustos para a criação de PDFs, como personalização detalhada do layout, conversão de HTML para PDF e integração com diversas fontes de dados. Ele simplifica tarefas complexas de PDF, permitindo que os desenvolvedores se concentrem na lógica principal do aplicativo.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

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

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim