Const em C# (Como funciona para desenvolvedores)

Declaração de variáveis ​​constantes

Para declarar uma variável constante, você usa a palavra-chave const seguida por um tipo de dado e, em seguida, a inicializa imediatamente. Por exemplo, const int myConstValue = 100; define uma constante inteira. É importante notar que uma variável constante deve ser inicializada quando é declarada, pois seu valor deve ser determinado em tempo de compilação e totalmente avaliado antes da execução do programa.

public class Program
{
    public const int MaxSize = 10;

    static void Main(string[] args)
    {
        Console.WriteLine(MaxSize);
    }
}

public class Program
{
    public const int MaxSize = 10;

    static void Main(string[] args)
    {
        Console.WriteLine(MaxSize);
    }
}

Public Class Program
	Public Const MaxSize As Integer = 10

	Shared Sub Main(ByVal args() As String)
		Console.WriteLine(MaxSize)
	End Sub
End Class

Este exemplo ilustra um uso simples de um número inteiro constante ( const int ) dentro de uma classe. A constante MaxSize é acessível dentro da mesma classe e pode ser usada diretamente no método estático void Main .

Variáveis ​​const vs. readonly

Embora as palavras-chave const e readonly sejam usadas para declarar valores imutáveis, existem diferenças importantes entre elas. Um campo const é uma constante de tempo de compilação, o que significa que seu valor é determinado em tempo de compilação e incorporado diretamente no código da Linguagem Intermediária (IL). Isso torna o valor estático e impossível de ser modificado.

Por outro lado, uma variável somente leitura pode ser atribuída tanto no momento da declaração quanto dentro de um construtor da classe. Isso permite alguma flexibilidade, já que os campos somente leitura podem ter valores diferentes dependendo do construtor usado para instanciar a classe.

public class Program
{
    public const string ConstExample = "Constant"; // const string
    public readonly string ReadonlyExample;

    public Program()
    {
        ReadonlyExample = "Initialized at runtime";
    }

    static void Main(string[] args)
    {
        Program p = new Program();
        Console.WriteLine(ConstExample);
        Console.WriteLine(p.ReadonlyExample);
    }
}

public class Program
{
    public const string ConstExample = "Constant"; // const string
    public readonly string ReadonlyExample;

    public Program()
    {
        ReadonlyExample = "Initialized at runtime";
    }

    static void Main(string[] args)
    {
        Program p = new Program();
        Console.WriteLine(ConstExample);
        Console.WriteLine(p.ReadonlyExample);
    }
}

Public Class Program
	Public Const ConstExample As String = "Constant" ' const string
	Public ReadOnly ReadonlyExample As String

	Public Sub New()
		ReadonlyExample = "Initialized at runtime"
	End Sub

	Shared Sub Main(ByVal args() As String)
		Dim p As New Program()
		Console.WriteLine(ConstExample)
		Console.WriteLine(p.ReadonlyExample)
	End Sub
End Class

Escopo das variáveis ​​constantes

Variáveis ​​constantes podem ser declaradas dentro de um método ou como membro de uma classe. Quando você declara uma variável constante dentro de um método, ela é conhecida como constante local. As constantes locais só podem ser acessadas dentro do método em que foram declaradas.

public class Program
{
    static void DemoMethod()
    {
        const int LocalConst = 5; // local constant
        Console.WriteLine(LocalConst);
    }
}

public class Program
{
    static void DemoMethod()
    {
        const int LocalConst = 5; // local constant
        Console.WriteLine(LocalConst);
    }
}

Public Class Program
	Private Shared Sub DemoMethod()
		Const LocalConst As Integer = 5 ' local constant
		Console.WriteLine(LocalConst)
	End Sub
End Class

Em contrapartida, quando uma constante é declarada dentro de uma classe, mas fora de qualquer método, ela é acessível a partir de qualquer função estática da mesma classe, porque os campos constantes são implicitamente estáticos. No entanto, tentar acessar um campo constante a partir de um método de instância sem referenciá-lo através do nome da classe resultará em um erro de compilação.

Constantes de tempo de compilação versus constantes de tempo de execução

A principal característica dos valores constantes é que eles são avaliados em tempo de compilação. Isso significa que o valor de um campo constante deve ser conhecido e totalmente avaliado pelo compilador. Isso contrasta com as variáveis ​​que são avaliadas em tempo de execução, cujos valores são determinados durante a execução do programa.

Por exemplo, tentar atribuir um valor a um campo constante com base em um cálculo realizado em tempo de execução causará um erro de compilação. O compilador exige que os valores constantes sejam atribuídos a partir de expressões constantes ou valores literais que sejam conhecidos em tempo de compilação.

const double Pi = Math.PI; // This will cause a compile time error

const double Pi = Math.PI; // This will cause a compile time error

Const Pi As Double = Math.PI ' This will cause a compile time error

Uso avançado de constantes e membros estáticos em C

Além dos conceitos básicos de const e readonly em C#, entender como trabalhar com expressões constantes, construtores estáticos e campos estáticos pode aprimorar suas práticas de programação, especialmente ao lidar com valores constantes que precisam ser compartilhados entre instâncias de uma classe.

public class Calculator
{
    public const int Multiplier = 2;
    public const int DoubleMultiplier = Multiplier * 2; // Constant expression
}

public class Calculator
{
    public const int Multiplier = 2;
    public const int DoubleMultiplier = Multiplier * 2; // Constant expression
}

Public Class Calculator
	Public Const Multiplier As Integer = 2
	Public Const DoubleMultiplier As Integer = Multiplier * 2 ' Constant expression
End Class

public class Program
{
    public static readonly string StartTime;

    static Program()
    {
        StartTime = DateTime.Now.ToString("T");
    }

    public static void DisplayStartTime()
    {
        Console.WriteLine($"Program started at: {StartTime}");
    }
}

public class Program
{
    public static readonly string StartTime;

    static Program()
    {
        StartTime = DateTime.Now.ToString("T");
    }

    public static void DisplayStartTime()
    {
        Console.WriteLine($"Program started at: {StartTime}");
    }
}

Public Class Program
	Public Shared ReadOnly StartTime As String

	Shared Sub New()
		StartTime = DateTime.Now.ToString("T")
	End Sub

	Public Shared Sub DisplayStartTime()
		Console.WriteLine($"Program started at: {StartTime}")
	End Sub
End Class

public class Configuration
{
    public static readonly int MaxUsers;
    public const int TimeoutSeconds = 30;

    static Configuration()
    {
        MaxUsers = FetchMaxUsersFromConfig();
    }

    private static int FetchMaxUsersFromConfig()
    {
        // Imagine this method reads from a configuration file
        return 100;
    }
}

public class Configuration
{
    public static readonly int MaxUsers;
    public const int TimeoutSeconds = 30;

    static Configuration()
    {
        MaxUsers = FetchMaxUsersFromConfig();
    }

    private static int FetchMaxUsersFromConfig()
    {
        // Imagine this method reads from a configuration file
        return 100;
    }
}

Public Class Configuration
	Public Shared ReadOnly MaxUsers As Integer
	Public Const TimeoutSeconds As Integer = 30

	Shared Sub New()
		MaxUsers = FetchMaxUsersFromConfig()
	End Sub

	Private Shared Function FetchMaxUsersFromConfig() As Integer
		' Imagine this method reads from a configuration file
		Return 100
	End Function
End Class

Introdução ao IronPDF

IronPDF é uma biblioteca versátil que permite aos desenvolvedores criar, editar e ler documentos PDF em aplicações .NET . Essa poderosa ferramenta simplifica a geração de PDFs, permitindo que os desenvolvedores convertam HTML em PDF, manipulem o conteúdo e extraiam dados de arquivos PDF com facilidade.

A principal vantagem do IronPDF reside na conversão de HTML para PDF , preservando tanto o layout quanto o estilo. É uma ferramenta ideal para gerar PDFs a partir de conteúdo da web, como relatórios, faturas e documentação. Arquivos HTML, URLs e strings HTML podem ser facilmente convertidos em arquivos PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

using IronPdf;

public class PdfGenerator
{
    // Defining a constant HTML template
    public const string HtmlTemplate = @"
        <html>
            <head>
                <title>PDF Report</title>
            </head>
            <body>
                <h1>IronPDF Report</h1>
                <p>This is a simple PDF document generated from HTML string using IronPDF.</p>
            </body>
        </html>";

    public static void CreatePdf(string filePath)
    {
        IronPdf.License.LicenseKey = "License";

        // Create a new PDF document from HTML template
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(HtmlTemplate);

        // Save the PDF document to a file
        pdf.SaveAs(filePath);
        Console.WriteLine($"PDF generated successfully at {filePath}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        PdfGenerator.CreatePdf("example.pdf");
    }
}

using IronPdf;

public class PdfGenerator
{
    // Defining a constant HTML template
    public const string HtmlTemplate = @"
        <html>
            <head>
                <title>PDF Report</title>
            </head>
            <body>
                <h1>IronPDF Report</h1>
                <p>This is a simple PDF document generated from HTML string using IronPDF.</p>
            </body>
        </html>";

    public static void CreatePdf(string filePath)
    {
        IronPdf.License.LicenseKey = "License";

        // Create a new PDF document from HTML template
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(HtmlTemplate);

        // Save the PDF document to a file
        pdf.SaveAs(filePath);
        Console.WriteLine($"PDF generated successfully at {filePath}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        PdfGenerator.CreatePdf("example.pdf");
    }
}

Imports IronPdf

Public Class PdfGenerator
	' Defining a constant HTML template
	Public Const HtmlTemplate As String = "
        <html>
            <head>
                <title>PDF Report</title>
            </head>
            <body>
                <h1>IronPDF Report</h1>
                <p>This is a simple PDF document generated from HTML string using IronPDF.</p>
            </body>
        </html>"

	Public Shared Sub CreatePdf(ByVal filePath As String)
		IronPdf.License.LicenseKey = "License"

		' Create a new PDF document from HTML template
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(HtmlTemplate)

		' Save the PDF document to a file
		pdf.SaveAs(filePath)
		Console.WriteLine($"PDF generated successfully at {filePath}")
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		PdfGenerator.CreatePdf("example.pdf")
	End Sub
End Class

Conclusão

Em C#, a palavra-chave const é um recurso valioso para definir valores imutáveis ​​que são conhecidos em tempo de compilação. Ela ajuda a melhorar a legibilidade e a manutenção do seu código, indicando claramente quais valores são constantes. Lembre-se: variáveis ​​const são implicitamente estáticas, devem ser inicializadas na declaração e seus valores devem ser constantes em tempo de compilação. Em comparação, as variáveis ​​somente leitura oferecem mais flexibilidade, mas são inicializadas em tempo de execução.

O IronPDF se destaca não apenas por seus recursos robustos de manipulação de PDFs, mas também por seu modelo de adoção flexível. Para desenvolvedores e organizações que desejam explorar suas funcionalidades, o IronPDF oferece um período de teste gratuito , proporcionando uma excelente oportunidade para avaliar seus recursos e facilidade de integração sem investimento inicial.

Quando estiver pronto para usar o IronPDF para fins comerciais, as opções de licenciamento começam em $799. Essa estrutura de preços foi projetada para atender às necessidades de projetos de diferentes tamanhos e tipos, garantindo que você possa escolher a licença que melhor se adapte aos seus planos de desenvolvimento e distribuição.