C# Const (Cómo Funciona para Desarrolladores)

Declaración de variables constantes

Para declarar una variable constante, utiliza la palabra clave const seguida de un tipo de dato y luego inicialízala inmediatamente. Por ejemplo, const int myConstValue = 100; define una constante entera. Es importante tener en cuenta que una variable constante debe ser inicializada en el momento de su declaración, ya que su valor está destinado a ser de tiempo de compilación y ser completamente evaluado antes de que el programa se ejecute.

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 ejemplo ilustra un uso simple de un entero constante (const int) dentro de una clase. La constante MaxSize es accesible dentro de la misma clase y puede ser utilizada directamente en el método static void Main.

Variables const. vs. readonly

Aunque tanto const como readonly se usan para declarar valores inmutables, existen diferencias importantes entre ellas. Un campo const es una constante de tiempo de compilación, lo que significa que su valor se determina en tiempo de compilación y se incrusta directamente en el código del Lenguaje Intermedio (IL). Esto lo hace estático y no puede modificarse.

Por otro lado, una variable readonly puede asignarse en el momento de la declaración o dentro de un constructor de la clase. Esto permite cierta flexibilidad, ya que los campos readonly pueden tener diferentes valores dependiendo del constructor utilizado para instanciar la clase.

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

Alcance de las variables const

Las variables constantes pueden declararse dentro de un método o como miembro de una clase. Cuando se declara una variable const dentro de un método, se le conoce como constante local. Las constantes locales solo son accesibles dentro del método en el que se declaran.

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

En contraste, cuando se declara un const dentro de una clase pero fuera de cualquier método, es accesible desde cualquier función estática del mismo, porque los campos const son implícitamente estáticos. Sin embargo, intentar acceder a un campo const desde un método de instancia sin referenciarlo a través del nombre de la clase resultará en un error de compilación.

Constantes en tiempo de compilación frente a constantes en tiempo de ejecución

La característica principal de los valores const es que se evalúan en tiempo de compilación. Esto significa que el valor de un campo const debe ser conocido y completamente evaluado por el compilador. Esto contrasta con las variables que se evalúan en tiempo de ejecución, cuyos valores se determinan durante la ejecución del programa.

Por ejemplo, intentar asignar un valor a un campo const basado en un cálculo realizado en tiempo de ejecución causará un error de tiempo de compilación. El compilador requiere que los valores const se asignen a partir de expresiones constantes o valores literales que sean conocidos en tiempo de compilación.

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 avanzado de constantes y miembros estáticos en C#;

Más allá de lo básico de const y readonly en C#, comprender cómo trabajar con expresiones constantes, constructores estáticos y campos estáticos puede elevar tus prácticas de codificación, especialmente cuando se trata de valores constantes que deben compartirse entre instancias de una clase.

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

Introducción a IronPDF

IronPDF es una biblioteca versátil que permite a los desarrolladores crear, editar y leer documentos PDF en aplicaciones .NET. Esta poderosa herramienta simplifica la generación de PDF al permitir a los desarrolladores convertir HTML a PDF, manipular contenido y extraer datos de archivos PDF con facilidad.

La fortaleza de IronPDF radica en convertir HTML a PDF, preservando tanto el diseño como el estilo. Es una herramienta ideal para generar PDFs a partir de contenido web, como informes, facturas y documentación. Los archivos HTML, las URL y las cadenas de HTML se pueden convertir fácilmente en archivos 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

Conclusión

En C#, la palabra clave const es una característica valiosa para definir valores inmutables que se conocen en tiempo de compilación. Ayuda a mejorar la legibilidad y mantenibilidad de tu código al indicar claramente cuáles valores son constantes. Recuerda, las variables const son implícitamente estáticas, deben inicializarse en la declaración y sus valores deben ser constantes de tiempo de compilación. En comparación, las variables readonly ofrecen más flexibilidad pero se inicializan en tiempo de ejecución.

IronPDF destaca no solo por sus robustas características en la manipulación de PDF sino también por su modelo de adopción flexible. Para desarrolladores y organizaciones que buscan explorar sus capacidades, IronPDF ofrece una prueba gratuita, proporcionando una excelente oportunidad para evaluar sus características y facilidad de integración sin una inversión inicial.

Cuando estén listos para avanzar con IronPDF para uso comercial, las opciones de licenciamiento comienzan desde $799. Esta estructura de precios está diseñada para acomodar las necesidades de diferentes tamaños y tipos de proyectos, asegurando que puedas elegir una licencia que mejor se adapte a tus planes de desarrollo y distribución.