Como posso converter HTML para PDF em C#?

Você pode usar o método RenderHtmlAsPdf do IronPDF para converter strings HTML em PDFs. Você também pode converter arquivos HTML em PDFs usando o RenderHtmlFileAsPdf .

Qual é a finalidade da palavra-chave `init` em C#?

A palavra-chave `init` permite definir propriedades que só podem ser alteradas durante a inicialização do objeto, garantindo sua imutabilidade posteriormente. Esse recurso é particularmente útil para criar objetos que não devem ser alterados após sua criação.

Como a palavra-chave `init` aprimora a imutabilidade de objetos em C#?

A palavra-chave `init` permite que as propriedades sejam definidas apenas durante a fase de inicialização do objeto, impedindo quaisquer alterações posteriores. Isso garante que os objetos permaneçam imutáveis após sua criação.

É possível usar propriedades de inicialização com bibliotecas para geração de PDFs?

Sim, as propriedades de inicialização podem ser usadas com bibliotecas como o IronPDF para gerar PDFs a partir de objetos imutáveis, garantindo que os dados usados para o PDF permaneçam consistentes durante todo o processo.

Quais são as vantagens de usar a palavra-chave `init` em vez dos métodos setters tradicionais?

O uso da palavra-chave `init` em vez dos métodos setters tradicionais promove a imutabilidade, reduz a necessidade de código de construtor extenso e garante que as propriedades do objeto não possam ser modificadas após a inicialização.

Como posso integrar a geração de PDFs com propriedades imutáveis em C#?

Você pode criar objetos imutáveis usando propriedades de inicialização e passar esses objetos para o IronPDF, que pode utilizar os dados para gerar documentos PDF consistentes e confiáveis.

Qual o papel da palavra-chave `init` na criação de aplicações C# modernas?

A palavra-chave `init` desempenha um papel crucial na criação de aplicações C# modernas, permitindo que os desenvolvedores definam objetos imutáveis com sintaxe concisa, aumentando a segurança do código e reduzindo erros.

Como posso instalar uma biblioteca para geração de PDF em um projeto C#?

Você pode instalar uma biblioteca como o IronPDF em seu projeto C# usando o Gerenciador de Pacotes NuGet com o comando: Install-Package IronPDF .

Por que a imutabilidade é importante no desenvolvimento de aplicações?

A imutabilidade é importante porque garante a integridade e a consistência dos dados em toda a sua aplicação, facilitando a manutenção e reduzindo a probabilidade de erros.

Que exemplos práticos ilustram o uso da palavra-chave `init`?

Um exemplo prático é o uso da palavra-chave `init` para definir uma classe com propriedades que só podem ser definidas durante a inicialização, garantindo que o objeto criado permaneça inalterado. Isso é particularmente útil em cenários onde a consistência dos dados é crucial.

A biblioteca C# PDF

Explore IronPDF Comece seu teste gratuito

HTML para PDF

Online Demo Veja todos os exemplos de código %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ATUALIZAÇÕES DO DESENVOLVEDOR

Palavra-chave Init em C# (Como funciona para desenvolvedores)

Curtis Chau

Updated: 21 de abril de 2026

A palavra-chave init no C# 9.0 introduziu uma nova maneira de definir propriedades de classe para a criação de objetos imutáveis. Em versões anteriores do C#, as propriedades eram normalmente usadas com os métodos de acesso get e set para ler e gravar em campos de objetos. No entanto, com o método init, você pode tornar as propriedades graváveis apenas durante a inicialização do objeto, tornando-as somente leitura posteriormente.

Este tutorial irá explorar o uso da palavra-chave init em C# com exemplos práticos e cenários utilizando a biblioteca IronPDF . Você também aprenderá sobre as diferenças cruciais entre os métodos setters de propriedades tradicionais (set) e os novos métodos setters que só funcionam com inicialização.

Exemplo básico da palavra-chave `init`

Vamos começar com um exemplo básico:

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

var person = new Person
{
    FirstName = "Iron",
    LastName = "Dev"
};

// person.FirstName = "Jane";  // This will give a compile-time error.

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

var person = new Person
{
    FirstName = "Iron",
    LastName = "Dev"
};

// person.FirstName = "Jane";  // This will give a compile-time error.

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Private person = New Person With {
	.FirstName = "Iron",
	.LastName = "Dev"
}

' person.FirstName = "Jane";  // This will give a compile-time error.

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Private person = New Person With {
	.FirstName = "Iron",
	.LastName = "Dev"
}

' person.FirstName = "Jane";  // This will give a compile-time error.

Palavra-chave C# Init (Como Funciona Para Desenvolvedores): Figura 1 - IDE lançando um erro devido a propriedades marcadas como somente init

Neste exemplo, FirstName e LastName são marcados como propriedades somente init. Isso significa que eles só podem ser atribuídos durante a inicialização do objeto. Após a criação do objeto, qualquer tentativa de alterar seus valores causará um erro de compilação.

Por que usar a palavra-chave `init`?

O principal motivo para usar a palavra-chave init é tornar as propriedades do objeto imutáveis após a inicialização. Tradicionalmente, você poderia marcar propriedades como somente leitura para obter imutabilidade. No entanto, muitas vezes você precisará de um construtor que aceite todos os valores necessários para definir os campos, o que pode levar a um código repetitivo no construtor. Com o init, você pode atingir o mesmo objetivo usando inicializadores de objetos sem escrever construtores longos.

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    // Without using constructor boilerplate for property initialization
}

var person = new Person
{
    FirstName = "John",
    LastName = "Doe"
};

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    // Without using constructor boilerplate for property initialization
}

var person = new Person
{
    FirstName = "John",
    LastName = "Doe"
};

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
	' Without using constructor boilerplate for property initialization
End Class

Private person = New Person With {
	.FirstName = "John",
	.LastName = "Doe"
}

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
	' Without using constructor boilerplate for property initialization
End Class

Private person = New Person With {
	.FirstName = "John",
	.LastName = "Doe"
}

Inicialização de objetos com propriedades somente de inicialização

O uso do init funciona perfeitamente com inicializadores de objetos. Em vez de depender de construtores para definir valores, você pode definir as propriedades necessárias diretamente ao criar um objeto.

public class Point
{
    public int X { get; init; }
    public int Y { get; init; }
}

var point = new Point { X = 10, Y = 20 };

// point.X = 30;  // This will throw a compile-time error

public class Point
{
    public int X { get; init; }
    public int Y { get; init; }
}

var point = new Point { X = 10, Y = 20 };

// point.X = 30;  // This will throw a compile-time error

Public Class Point
	Public Property X() As Integer
	Public Property Y() As Integer
End Class

Private point = New Point With {
	.X = 10,
	.Y = 20
}

' point.X = 30;  // This will throw a compile-time error

Public Class Point
	Public Property X() As Integer
	Public Property Y() As Integer
End Class

Private point = New Point With {
	.X = 10,
	.Y = 20
}

' point.X = 30;  // This will throw a compile-time error

Isso cria um objeto simples e imutável do tipo Point. Note que os valores de X e Y são definidos na inicialização e não podem ser modificados depois.

Misturando inicialização com construtores

Embora o principal caso de uso para init seja a inicialização de objetos por meio de inicializadores de objetos, você ainda pode usar um construtor, se necessário. Isso é particularmente útil ao impor valores de propriedade específicos durante a criação de objetos.

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }

    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }

    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String

	Public Sub New(ByVal firstName As String, ByVal lastName As String)
		Me.FirstName = firstName
		Me.LastName = lastName
	End Sub
End Class

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String

	Public Sub New(ByVal firstName As String, ByVal lastName As String)
		Me.FirstName = firstName
		Me.LastName = lastName
	End Sub
End Class

Você pode usar tanto construtores quanto propriedades de inicialização em conjunto. Essa abordagem oferece mais flexibilidade, ao mesmo tempo que garante a imutabilidade após a construção do objeto.

Vantagens do conjunto inicial em relação ao conjunto privado

Anteriormente, os desenvolvedores usavam um acessador de conjunto privado para limitar a modificação de propriedades fora da classe.

public class Person
{
    public string FirstName { get; private set; }
    public string LastName { get; private set; }

    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

public class Person
{
    public string FirstName { get; private set; }
    public string LastName { get; private set; }

    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

Public Class Person
	Private privateFirstName As String
	Public Property FirstName() As String
		Get
			Return privateFirstName
		End Get
		Private Set(ByVal value As String)
			privateFirstName = value
		End Set
	End Property
	Private privateLastName As String
	Public Property LastName() As String
		Get
			Return privateLastName
		End Get
		Private Set(ByVal value As String)
			privateLastName = value
		End Set
	End Property

	Public Sub New(ByVal firstName As String, ByVal lastName As String)
		Me.FirstName = firstName
		Me.LastName = lastName
	End Sub
End Class

Public Class Person
	Private privateFirstName As String
	Public Property FirstName() As String
		Get
			Return privateFirstName
		End Get
		Private Set(ByVal value As String)
			privateFirstName = value
		End Set
	End Property
	Private privateLastName As String
	Public Property LastName() As String
		Get
			Return privateLastName
		End Get
		Private Set(ByVal value As String)
			privateLastName = value
		End Set
	End Property

	Public Sub New(ByVal firstName As String, ByVal lastName As String)
		Me.FirstName = firstName
		Me.LastName = lastName
	End Sub
End Class

Embora essa abordagem funcione, ela exige código repetitivo no construtor para inicializar as propriedades. Além disso, permite que a própria classe modifique as propriedades posteriormente, o que nem sempre é ideal para objetos imutáveis. A palavra-chave init resolve esse problema, pois permite a inicialização apenas no momento da criação do objeto e bloqueia qualquer modificação posterior.

Lidando com a inicialização de campos somente leitura e acessadores de inicialização.

A palavra-chave init pode inicializar campos ou propriedades durante a criação de um objeto, mantendo-os imutáveis posteriormente. Embora os campos somente leitura ofereçam imutabilidade, o acessador init oferece uma capacidade semelhante para propriedades. Eis como você pode lidar com a imutabilidade de duas maneiras: usando campos somente leitura e propriedades de inicialização.

Utilizando campos somente leitura com um construtor

Neste exemplo, usamos campos somente leitura para firstName e lastName, que são definidos durante a construção do objeto. Esses campos só podem ser atribuídos uma vez no construtor e não podem ser modificados posteriormente:

public class Person
{
    private readonly string firstName;
    private readonly string lastName;

    public string FirstName => firstName;
    public string LastName => lastName;

    public Person(string firstName, string lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

public class Person
{
    private readonly string firstName;
    private readonly string lastName;

    public string FirstName => firstName;
    public string LastName => lastName;

    public Person(string firstName, string lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

Public Class Person
'INSTANT VB NOTE: The field firstName was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private ReadOnly firstName_Conflict As String
'INSTANT VB NOTE: The field lastName was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private ReadOnly lastName_Conflict As String

	Public ReadOnly Property FirstName() As String
		Get
			Return firstName_Conflict
		End Get
	End Property
	Public ReadOnly Property LastName() As String
		Get
			Return lastName_Conflict
		End Get
	End Property

	Public Sub New(ByVal firstName As String, ByVal lastName As String)
		Me.firstName_Conflict = firstName
		Me.lastName_Conflict = lastName
	End Sub
End Class

Public Class Person
'INSTANT VB NOTE: The field firstName was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private ReadOnly firstName_Conflict As String
'INSTANT VB NOTE: The field lastName was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private ReadOnly lastName_Conflict As String

	Public ReadOnly Property FirstName() As String
		Get
			Return firstName_Conflict
		End Get
	End Property
	Public ReadOnly Property LastName() As String
		Get
			Return lastName_Conflict
		End Get
	End Property

	Public Sub New(ByVal firstName As String, ByVal lastName As String)
		Me.firstName_Conflict = firstName
		Me.lastName_Conflict = lastName
	End Sub
End Class

Utilizando acessadores de inicialização para inicialização

Alternativamente, podemos usar o acessador init para criar propriedades somente leitura que podem ser inicializadas durante a criação do objeto, mas não podem ser alteradas posteriormente. Isso elimina a necessidade de campos somente leitura e fornece uma sintaxe mais moderna:

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

public class Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Introdução ao IronPDF

Palavra-chave C# Init (Como Funciona Para Desenvolvedores): Figura 2 - IronPDF: A Biblioteca PDF C#

IronPDF é uma poderosa biblioteca para geração e manipulação de PDFs, projetada para desenvolvedores C#. Simplifica o trabalho com PDFs, convertendo HTML , CSS, imagens e outros conteúdos em documentos PDF. Com recursos como renderização perfeita em pixels, suporte multiplataforma e fácil integração em projetos .NET , o IronPDF é ideal para desenvolvedores que precisam criar PDFs de alta qualidade rapidamente. Você pode usá-lo com .NET Core, Framework e Standard, e ele oferece suporte a uma ampla gama de plataformas, incluindo Windows, Linux e macOS.

Case: Usando IronPDF com a Palavra-chave Init do C#

Para criar objetos imutáveis em um projeto C# durante a geração de PDFs, você pode combinar a palavra-chave init com o IronPDF. A palavra-chave init garante a integridade do objeto após sua inicialização, enquanto o IronPDF processa os dados e gera PDFs com base nesse modelo imutável.

Certifique-se de que o IronPDF esteja referenciado corretamente em seu projeto. Você pode instalá-lo via NuGet:

PM > Install-Package IronPdf

Install-Package IronPdf

Aqui está um exemplo de código:

using IronPdf;

public class Person
{
    public int Id { get; init; }
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

public class PDFGenerator
{
    public static void CreatePersonPDF(Person person)
    {
        var htmlContent = $@"
        <html>
        <body>
            <h1>Person Information</h1>
            <p>ID: {person.Id}</p>
            <p>First Name: {person.FirstName}</p>
            <p>Last Name: {person.LastName}</p>
        </body>
        </html>";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs($"Person_{person.Id}.pdf");
    }
}

class Program
{
    static void Main(string[] args)
    {
        var person = new Person
        {
            Id = 1,
            FirstName = "Iron",
            LastName = "Dev"
        };

        PDFGenerator.CreatePersonPDF(person);
    }
}

using IronPdf;

public class Person
{
    public int Id { get; init; }
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

public class PDFGenerator
{
    public static void CreatePersonPDF(Person person)
    {
        var htmlContent = $@"
        <html>
        <body>
            <h1>Person Information</h1>
            <p>ID: {person.Id}</p>
            <p>First Name: {person.FirstName}</p>
            <p>Last Name: {person.LastName}</p>
        </body>
        </html>";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs($"Person_{person.Id}.pdf");
    }
}

class Program
{
    static void Main(string[] args)
    {
        var person = new Person
        {
            Id = 1,
            FirstName = "Iron",
            LastName = "Dev"
        };

        PDFGenerator.CreatePersonPDF(person);
    }
}

Imports IronPdf

Public Class Person
	Public Property Id() As Integer
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Public Class PDFGenerator
	Public Shared Sub CreatePersonPDF(ByVal person As Person)
		Dim htmlContent = $"
        <html>
        <body>
            <h1>Person Information</h1>
            <p>ID: {person.Id}</p>
            <p>First Name: {person.FirstName}</p>
            <p>Last Name: {person.LastName}</p>
        </body>
        </html>"

		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		pdf.SaveAs($"Person_{person.Id}.pdf")
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim person As New Person With {
			.Id = 1,
			.FirstName = "Iron",
			.LastName = "Dev"
		}

		PDFGenerator.CreatePersonPDF(person)
	End Sub
End Class

Imports IronPdf

Public Class Person
	Public Property Id() As Integer
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Public Class PDFGenerator
	Public Shared Sub CreatePersonPDF(ByVal person As Person)
		Dim htmlContent = $"
        <html>
        <body>
            <h1>Person Information</h1>
            <p>ID: {person.Id}</p>
            <p>First Name: {person.FirstName}</p>
            <p>Last Name: {person.LastName}</p>
        </body>
        </html>"

		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		pdf.SaveAs($"Person_{person.Id}.pdf")
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim person As New Person With {
			.Id = 1,
			.FirstName = "Iron",
			.LastName = "Dev"
		}

		PDFGenerator.CreatePersonPDF(person)
	End Sub
End Class

Conclusão

Palavra-chave C# Init (Como Funciona Para Desenvolvedores): Figura 3 - Página de Licenciamento do IronPDF

Em resumo, a palavra-chave init do C# permite criar objetos imutáveis, oferecendo flexibilidade durante a inicialização do objeto. É uma alternativa mais limpa e segura aos acessadores de conjuntos privados, reduzindo a necessidade de código repetitivo no construtor. A combinação da palavra-chave init com campos somente leitura, structs e lógica de validação ajuda a construir estruturas de dados robustas e seguras que preservam a imutabilidade sem sacrificar a legibilidade ou a flexibilidade. IronPDF oferece um teste gratuito, e licenças começam a partir de $999. Isso lhe dá acesso a todos os seus recursos, incluindo edição, compressão e proteção de PDFs.

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 bem estruturados e visualmente atraentes.

...